
// Generated from ./ANTLRv4Parser.g4 by ANTLR 4.8


#include <string>
#include "../ANTLRv4ParserBase.hpp"


#include "ANTLRv4ParserListener.h"
#include "ANTLRv4ParserVisitor.h"

#include "ANTLRv4Parser.h"


using boolean = bool;
using CppString = std::string;


using namespace antlrcpp;
using namespace antlr4;

ANTLRv4Parser::ANTLRv4Parser(TokenStream *input) : ANTLRv4ParserBase(input) {
  _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
}

ANTLRv4Parser::~ANTLRv4Parser() {
  delete _interpreter;
}

std::string ANTLRv4Parser::getGrammarFileName() const {
  return "ANTLRv4Parser.g4";
}

const std::vector<std::string>& ANTLRv4Parser::getRuleNames() const {
  return _ruleNames;
}

dfa::Vocabulary& ANTLRv4Parser::getVocabulary() const {
  return _vocabulary;
}


//----------------- GrammarSpecContext ------------------------------------------------------------------

ANTLRv4Parser::GrammarSpecContext::GrammarSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::GrammarTypeContext* ANTLRv4Parser::GrammarSpecContext::grammarType() {
  return getRuleContext<ANTLRv4Parser::GrammarTypeContext>(0);
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::GrammarSpecContext::id() {
  return getRuleContext<ANTLRv4Parser::IdContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::GrammarSpecContext::SEMI() {
  return getToken(ANTLRv4Parser::SEMI, 0);
}

ANTLRv4Parser::RulesContext* ANTLRv4Parser::GrammarSpecContext::rules() {
  return getRuleContext<ANTLRv4Parser::RulesContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::GrammarSpecContext::EOF() {
  return getToken(ANTLRv4Parser::EOF, 0);
}

tree::TerminalNode* ANTLRv4Parser::GrammarSpecContext::DOC_COMMENT() {
  return getToken(ANTLRv4Parser::DOC_COMMENT, 0);
}

std::vector<ANTLRv4Parser::PrequelConstructContext *> ANTLRv4Parser::GrammarSpecContext::prequelConstruct() {
  return getRuleContexts<ANTLRv4Parser::PrequelConstructContext>();
}

ANTLRv4Parser::PrequelConstructContext* ANTLRv4Parser::GrammarSpecContext::prequelConstruct(size_t i) {
  return getRuleContext<ANTLRv4Parser::PrequelConstructContext>(i);
}

std::vector<ANTLRv4Parser::ModeSpecContext *> ANTLRv4Parser::GrammarSpecContext::modeSpec() {
  return getRuleContexts<ANTLRv4Parser::ModeSpecContext>();
}

ANTLRv4Parser::ModeSpecContext* ANTLRv4Parser::GrammarSpecContext::modeSpec(size_t i) {
  return getRuleContext<ANTLRv4Parser::ModeSpecContext>(i);
}


size_t ANTLRv4Parser::GrammarSpecContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleGrammarSpec;
}

void ANTLRv4Parser::GrammarSpecContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGrammarSpec(this);
}

void ANTLRv4Parser::GrammarSpecContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGrammarSpec(this);
}


antlrcpp::Any ANTLRv4Parser::GrammarSpecContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitGrammarSpec(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::GrammarSpecContext* ANTLRv4Parser::grammarSpec() {
  GrammarSpecContext *_localctx = _tracker.createInstance<GrammarSpecContext>(_ctx, getState());
  enterRule(_localctx, 0, ANTLRv4Parser::RuleGrammarSpec);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(143);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == ANTLRv4Parser::DOC_COMMENT) {
      setState(142);
      match(ANTLRv4Parser::DOC_COMMENT);
    }
    setState(145);
    grammarType();
    setState(146);
    id();
    setState(147);
    match(ANTLRv4Parser::SEMI);
    setState(151);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << ANTLRv4Parser::OPTIONS)
      | (1ULL << ANTLRv4Parser::TOKENS)
      | (1ULL << ANTLRv4Parser::IMPORT)
      | (1ULL << ANTLRv4Parser::AT))) != 0)) {
      setState(148);
      prequelConstruct();
      setState(153);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(154);
    rules();
    setState(158);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == ANTLRv4Parser::MODE) {
      setState(155);
      modeSpec();
      setState(160);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(161);
    match(ANTLRv4Parser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GrammarTypeContext ------------------------------------------------------------------

ANTLRv4Parser::GrammarTypeContext::GrammarTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::GrammarTypeContext::LEXER() {
  return getToken(ANTLRv4Parser::LEXER, 0);
}

tree::TerminalNode* ANTLRv4Parser::GrammarTypeContext::GRAMMAR() {
  return getToken(ANTLRv4Parser::GRAMMAR, 0);
}

tree::TerminalNode* ANTLRv4Parser::GrammarTypeContext::PARSER() {
  return getToken(ANTLRv4Parser::PARSER, 0);
}


size_t ANTLRv4Parser::GrammarTypeContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleGrammarType;
}

void ANTLRv4Parser::GrammarTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGrammarType(this);
}

void ANTLRv4Parser::GrammarTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGrammarType(this);
}


antlrcpp::Any ANTLRv4Parser::GrammarTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitGrammarType(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::GrammarTypeContext* ANTLRv4Parser::grammarType() {
  GrammarTypeContext *_localctx = _tracker.createInstance<GrammarTypeContext>(_ctx, getState());
  enterRule(_localctx, 2, ANTLRv4Parser::RuleGrammarType);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(168);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case ANTLRv4Parser::LEXER: {
        setState(163);
        match(ANTLRv4Parser::LEXER);
        setState(164);
        match(ANTLRv4Parser::GRAMMAR);
        break;
      }

      case ANTLRv4Parser::PARSER: {
        setState(165);
        match(ANTLRv4Parser::PARSER);
        setState(166);
        match(ANTLRv4Parser::GRAMMAR);
        break;
      }

      case ANTLRv4Parser::GRAMMAR: {
        setState(167);
        match(ANTLRv4Parser::GRAMMAR);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PrequelConstructContext ------------------------------------------------------------------

ANTLRv4Parser::PrequelConstructContext::PrequelConstructContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::OptionsSpecContext* ANTLRv4Parser::PrequelConstructContext::optionsSpec() {
  return getRuleContext<ANTLRv4Parser::OptionsSpecContext>(0);
}

ANTLRv4Parser::DelegateGrammarsContext* ANTLRv4Parser::PrequelConstructContext::delegateGrammars() {
  return getRuleContext<ANTLRv4Parser::DelegateGrammarsContext>(0);
}

ANTLRv4Parser::TokensSpecContext* ANTLRv4Parser::PrequelConstructContext::tokensSpec() {
  return getRuleContext<ANTLRv4Parser::TokensSpecContext>(0);
}

ANTLRv4Parser::ActionContext* ANTLRv4Parser::PrequelConstructContext::action() {
  return getRuleContext<ANTLRv4Parser::ActionContext>(0);
}


size_t ANTLRv4Parser::PrequelConstructContext::getRuleIndex() const {
  return ANTLRv4Parser::RulePrequelConstruct;
}

void ANTLRv4Parser::PrequelConstructContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPrequelConstruct(this);
}

void ANTLRv4Parser::PrequelConstructContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPrequelConstruct(this);
}


antlrcpp::Any ANTLRv4Parser::PrequelConstructContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitPrequelConstruct(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::PrequelConstructContext* ANTLRv4Parser::prequelConstruct() {
  PrequelConstructContext *_localctx = _tracker.createInstance<PrequelConstructContext>(_ctx, getState());
  enterRule(_localctx, 4, ANTLRv4Parser::RulePrequelConstruct);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(174);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case ANTLRv4Parser::OPTIONS: {
        enterOuterAlt(_localctx, 1);
        setState(170);
        optionsSpec();
        break;
      }

      case ANTLRv4Parser::IMPORT: {
        enterOuterAlt(_localctx, 2);
        setState(171);
        delegateGrammars();
        break;
      }

      case ANTLRv4Parser::TOKENS: {
        enterOuterAlt(_localctx, 3);
        setState(172);
        tokensSpec();
        break;
      }

      case ANTLRv4Parser::AT: {
        enterOuterAlt(_localctx, 4);
        setState(173);
        action();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OptionsSpecContext ------------------------------------------------------------------

ANTLRv4Parser::OptionsSpecContext::OptionsSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::OptionsSpecContext::OPTIONS() {
  return getToken(ANTLRv4Parser::OPTIONS, 0);
}

tree::TerminalNode* ANTLRv4Parser::OptionsSpecContext::RBRACE() {
  return getToken(ANTLRv4Parser::RBRACE, 0);
}

std::vector<ANTLRv4Parser::OptionContext *> ANTLRv4Parser::OptionsSpecContext::option() {
  return getRuleContexts<ANTLRv4Parser::OptionContext>();
}

ANTLRv4Parser::OptionContext* ANTLRv4Parser::OptionsSpecContext::option(size_t i) {
  return getRuleContext<ANTLRv4Parser::OptionContext>(i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::OptionsSpecContext::SEMI() {
  return getTokens(ANTLRv4Parser::SEMI);
}

tree::TerminalNode* ANTLRv4Parser::OptionsSpecContext::SEMI(size_t i) {
  return getToken(ANTLRv4Parser::SEMI, i);
}


size_t ANTLRv4Parser::OptionsSpecContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleOptionsSpec;
}

void ANTLRv4Parser::OptionsSpecContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOptionsSpec(this);
}

void ANTLRv4Parser::OptionsSpecContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOptionsSpec(this);
}


antlrcpp::Any ANTLRv4Parser::OptionsSpecContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitOptionsSpec(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::OptionsSpecContext* ANTLRv4Parser::optionsSpec() {
  OptionsSpecContext *_localctx = _tracker.createInstance<OptionsSpecContext>(_ctx, getState());
  enterRule(_localctx, 6, ANTLRv4Parser::RuleOptionsSpec);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(176);
    match(ANTLRv4Parser::OPTIONS);
    setState(182);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == ANTLRv4Parser::TOKEN_REF

    || _la == ANTLRv4Parser::RULE_REF) {
      setState(177);
      option();
      setState(178);
      match(ANTLRv4Parser::SEMI);
      setState(184);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(185);
    match(ANTLRv4Parser::RBRACE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OptionContext ------------------------------------------------------------------

ANTLRv4Parser::OptionContext::OptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::OptionContext::id() {
  return getRuleContext<ANTLRv4Parser::IdContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::OptionContext::ASSIGN() {
  return getToken(ANTLRv4Parser::ASSIGN, 0);
}

ANTLRv4Parser::OptionValueContext* ANTLRv4Parser::OptionContext::optionValue() {
  return getRuleContext<ANTLRv4Parser::OptionValueContext>(0);
}


size_t ANTLRv4Parser::OptionContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleOption;
}

void ANTLRv4Parser::OptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOption(this);
}

void ANTLRv4Parser::OptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOption(this);
}


antlrcpp::Any ANTLRv4Parser::OptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitOption(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::OptionContext* ANTLRv4Parser::option() {
  OptionContext *_localctx = _tracker.createInstance<OptionContext>(_ctx, getState());
  enterRule(_localctx, 8, ANTLRv4Parser::RuleOption);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(187);
    id();
    setState(188);
    match(ANTLRv4Parser::ASSIGN);
    setState(189);
    optionValue();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OptionValueContext ------------------------------------------------------------------

ANTLRv4Parser::OptionValueContext::OptionValueContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::QidContext* ANTLRv4Parser::OptionValueContext::qid() {
  return getRuleContext<ANTLRv4Parser::QidContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::OptionValueContext::STRING_LITERAL() {
  return getToken(ANTLRv4Parser::STRING_LITERAL, 0);
}

tree::TerminalNode* ANTLRv4Parser::OptionValueContext::INT() {
  return getToken(ANTLRv4Parser::INT, 0);
}

tree::TerminalNode* ANTLRv4Parser::OptionValueContext::STAR() {
  return getToken(ANTLRv4Parser::STAR, 0);
}


size_t ANTLRv4Parser::OptionValueContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleOptionValue;
}

void ANTLRv4Parser::OptionValueContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOptionValue(this);
}

void ANTLRv4Parser::OptionValueContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOptionValue(this);
}


antlrcpp::Any ANTLRv4Parser::OptionValueContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitOptionValue(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::OptionValueContext* ANTLRv4Parser::optionValue() {
  OptionValueContext *_localctx = _tracker.createInstance<OptionValueContext>(_ctx, getState());
  enterRule(_localctx, 10, ANTLRv4Parser::RuleOptionValue);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(195);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case ANTLRv4Parser::TOKEN_REF:
      case ANTLRv4Parser::RULE_REF: {
        enterOuterAlt(_localctx, 1);
        setState(191);
        qid();
        break;
      }

      case ANTLRv4Parser::STRING_LITERAL: {
        enterOuterAlt(_localctx, 2);
        setState(192);
        match(ANTLRv4Parser::STRING_LITERAL);
        break;
      }

      case ANTLRv4Parser::INT: {
        enterOuterAlt(_localctx, 3);
        setState(193);
        match(ANTLRv4Parser::INT);
        break;
      }

      case ANTLRv4Parser::STAR: {
        enterOuterAlt(_localctx, 4);
        setState(194);
        match(ANTLRv4Parser::STAR);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DelegateGrammarsContext ------------------------------------------------------------------

ANTLRv4Parser::DelegateGrammarsContext::DelegateGrammarsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::DelegateGrammarsContext::IMPORT() {
  return getToken(ANTLRv4Parser::IMPORT, 0);
}

std::vector<ANTLRv4Parser::DelegateGrammarContext *> ANTLRv4Parser::DelegateGrammarsContext::delegateGrammar() {
  return getRuleContexts<ANTLRv4Parser::DelegateGrammarContext>();
}

ANTLRv4Parser::DelegateGrammarContext* ANTLRv4Parser::DelegateGrammarsContext::delegateGrammar(size_t i) {
  return getRuleContext<ANTLRv4Parser::DelegateGrammarContext>(i);
}

tree::TerminalNode* ANTLRv4Parser::DelegateGrammarsContext::SEMI() {
  return getToken(ANTLRv4Parser::SEMI, 0);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::DelegateGrammarsContext::COMMA() {
  return getTokens(ANTLRv4Parser::COMMA);
}

tree::TerminalNode* ANTLRv4Parser::DelegateGrammarsContext::COMMA(size_t i) {
  return getToken(ANTLRv4Parser::COMMA, i);
}


size_t ANTLRv4Parser::DelegateGrammarsContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleDelegateGrammars;
}

void ANTLRv4Parser::DelegateGrammarsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDelegateGrammars(this);
}

void ANTLRv4Parser::DelegateGrammarsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDelegateGrammars(this);
}


antlrcpp::Any ANTLRv4Parser::DelegateGrammarsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitDelegateGrammars(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::DelegateGrammarsContext* ANTLRv4Parser::delegateGrammars() {
  DelegateGrammarsContext *_localctx = _tracker.createInstance<DelegateGrammarsContext>(_ctx, getState());
  enterRule(_localctx, 12, ANTLRv4Parser::RuleDelegateGrammars);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(197);
    match(ANTLRv4Parser::IMPORT);
    setState(198);
    delegateGrammar();
    setState(203);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == ANTLRv4Parser::COMMA) {
      setState(199);
      match(ANTLRv4Parser::COMMA);
      setState(200);
      delegateGrammar();
      setState(205);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(206);
    match(ANTLRv4Parser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DelegateGrammarContext ------------------------------------------------------------------

ANTLRv4Parser::DelegateGrammarContext::DelegateGrammarContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<ANTLRv4Parser::IdContext *> ANTLRv4Parser::DelegateGrammarContext::id() {
  return getRuleContexts<ANTLRv4Parser::IdContext>();
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::DelegateGrammarContext::id(size_t i) {
  return getRuleContext<ANTLRv4Parser::IdContext>(i);
}

tree::TerminalNode* ANTLRv4Parser::DelegateGrammarContext::ASSIGN() {
  return getToken(ANTLRv4Parser::ASSIGN, 0);
}


size_t ANTLRv4Parser::DelegateGrammarContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleDelegateGrammar;
}

void ANTLRv4Parser::DelegateGrammarContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDelegateGrammar(this);
}

void ANTLRv4Parser::DelegateGrammarContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDelegateGrammar(this);
}


antlrcpp::Any ANTLRv4Parser::DelegateGrammarContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitDelegateGrammar(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::DelegateGrammarContext* ANTLRv4Parser::delegateGrammar() {
  DelegateGrammarContext *_localctx = _tracker.createInstance<DelegateGrammarContext>(_ctx, getState());
  enterRule(_localctx, 14, ANTLRv4Parser::RuleDelegateGrammar);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(213);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 8, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(208);
      id();
      setState(209);
      match(ANTLRv4Parser::ASSIGN);
      setState(210);
      id();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(212);
      id();
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TokensSpecContext ------------------------------------------------------------------

ANTLRv4Parser::TokensSpecContext::TokensSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::TokensSpecContext::TOKENS() {
  return getToken(ANTLRv4Parser::TOKENS, 0);
}

std::vector<ANTLRv4Parser::IdContext *> ANTLRv4Parser::TokensSpecContext::id() {
  return getRuleContexts<ANTLRv4Parser::IdContext>();
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::TokensSpecContext::id(size_t i) {
  return getRuleContext<ANTLRv4Parser::IdContext>(i);
}

tree::TerminalNode* ANTLRv4Parser::TokensSpecContext::RBRACE() {
  return getToken(ANTLRv4Parser::RBRACE, 0);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::TokensSpecContext::COMMA() {
  return getTokens(ANTLRv4Parser::COMMA);
}

tree::TerminalNode* ANTLRv4Parser::TokensSpecContext::COMMA(size_t i) {
  return getToken(ANTLRv4Parser::COMMA, i);
}


size_t ANTLRv4Parser::TokensSpecContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleTokensSpec;
}

void ANTLRv4Parser::TokensSpecContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTokensSpec(this);
}

void ANTLRv4Parser::TokensSpecContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTokensSpec(this);
}


antlrcpp::Any ANTLRv4Parser::TokensSpecContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitTokensSpec(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::TokensSpecContext* ANTLRv4Parser::tokensSpec() {
  TokensSpecContext *_localctx = _tracker.createInstance<TokensSpecContext>(_ctx, getState());
  enterRule(_localctx, 16, ANTLRv4Parser::RuleTokensSpec);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(215);
    match(ANTLRv4Parser::TOKENS);
    setState(216);
    id();
    setState(221);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(217);
        match(ANTLRv4Parser::COMMA);
        setState(218);
        id(); 
      }
      setState(223);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx);
    }
    setState(225);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == ANTLRv4Parser::COMMA) {
      setState(224);
      match(ANTLRv4Parser::COMMA);
    }
    setState(227);
    match(ANTLRv4Parser::RBRACE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ActionBlockContext ------------------------------------------------------------------

ANTLRv4Parser::ActionBlockContext::ActionBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::BEGIN_ACTION() {
  return getToken(ANTLRv4Parser::BEGIN_ACTION, 0);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::END_ACTION() {
  return getToken(ANTLRv4Parser::END_ACTION, 0);
}

std::vector<ANTLRv4Parser::ActionBlockContext *> ANTLRv4Parser::ActionBlockContext::actionBlock() {
  return getRuleContexts<ANTLRv4Parser::ActionBlockContext>();
}

ANTLRv4Parser::ActionBlockContext* ANTLRv4Parser::ActionBlockContext::actionBlock(size_t i) {
  return getRuleContext<ANTLRv4Parser::ActionBlockContext>(i);
}

std::vector<ANTLRv4Parser::ActionExpressionContext *> ANTLRv4Parser::ActionBlockContext::actionExpression() {
  return getRuleContexts<ANTLRv4Parser::ActionExpressionContext>();
}

ANTLRv4Parser::ActionExpressionContext* ANTLRv4Parser::ActionBlockContext::actionExpression(size_t i) {
  return getRuleContext<ANTLRv4Parser::ActionExpressionContext>(i);
}

std::vector<ANTLRv4Parser::ActionScopeExpressionContext *> ANTLRv4Parser::ActionBlockContext::actionScopeExpression() {
  return getRuleContexts<ANTLRv4Parser::ActionScopeExpressionContext>();
}

ANTLRv4Parser::ActionScopeExpressionContext* ANTLRv4Parser::ActionBlockContext::actionScopeExpression(size_t i) {
  return getRuleContext<ANTLRv4Parser::ActionScopeExpressionContext>(i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_WS() {
  return getTokens(ANTLRv4Parser::ACTION_WS);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_WS(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_WS, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_NEWLINE() {
  return getTokens(ANTLRv4Parser::ACTION_NEWLINE);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_NEWLINE(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_NEWLINE, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_COMMENT() {
  return getTokens(ANTLRv4Parser::ACTION_COMMENT);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_COMMENT(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_COMMENT, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_LITERAL() {
  return getTokens(ANTLRv4Parser::ACTION_LITERAL);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_LITERAL(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_LITERAL, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_TEXT() {
  return getTokens(ANTLRv4Parser::ACTION_TEXT);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_TEXT(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_TEXT, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_LT() {
  return getTokens(ANTLRv4Parser::ACTION_LT);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_LT(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_LT, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_GT() {
  return getTokens(ANTLRv4Parser::ACTION_GT);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_GT(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_GT, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_LPAREN() {
  return getTokens(ANTLRv4Parser::ACTION_LPAREN);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_LPAREN(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_LPAREN, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_RPAREN() {
  return getTokens(ANTLRv4Parser::ACTION_RPAREN);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_RPAREN(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_RPAREN, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_LBRACK() {
  return getTokens(ANTLRv4Parser::ACTION_LBRACK);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_LBRACK(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_LBRACK, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_RBRACK() {
  return getTokens(ANTLRv4Parser::ACTION_RBRACK);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_RBRACK(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_RBRACK, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_EQUALS() {
  return getTokens(ANTLRv4Parser::ACTION_EQUALS);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_EQUALS(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_EQUALS, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_COMMA() {
  return getTokens(ANTLRv4Parser::ACTION_COMMA);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_COMMA(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_COMMA, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_ESCAPE() {
  return getTokens(ANTLRv4Parser::ACTION_ESCAPE);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_ESCAPE(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_ESCAPE, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_WORD() {
  return getTokens(ANTLRv4Parser::ACTION_WORD);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_WORD(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_WORD, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_REFERENCE() {
  return getTokens(ANTLRv4Parser::ACTION_REFERENCE);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_REFERENCE(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_REFERENCE, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_COLON() {
  return getTokens(ANTLRv4Parser::ACTION_COLON);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_COLON(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_COLON, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_COLON2() {
  return getTokens(ANTLRv4Parser::ACTION_COLON2);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_COLON2(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_COLON2, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_MINUS() {
  return getTokens(ANTLRv4Parser::ACTION_MINUS);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_MINUS(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_MINUS, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionBlockContext::ACTION_DOT() {
  return getTokens(ANTLRv4Parser::ACTION_DOT);
}

tree::TerminalNode* ANTLRv4Parser::ActionBlockContext::ACTION_DOT(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_DOT, i);
}


size_t ANTLRv4Parser::ActionBlockContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleActionBlock;
}

void ANTLRv4Parser::ActionBlockContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterActionBlock(this);
}

void ANTLRv4Parser::ActionBlockContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitActionBlock(this);
}


antlrcpp::Any ANTLRv4Parser::ActionBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitActionBlock(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ActionBlockContext* ANTLRv4Parser::actionBlock() {
  ActionBlockContext *_localctx = _tracker.createInstance<ActionBlockContext>(_ctx, getState());
  enterRule(_localctx, 18, ANTLRv4Parser::RuleActionBlock);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(229);
    match(ANTLRv4Parser::BEGIN_ACTION);
    setState(255);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == ANTLRv4Parser::BEGIN_ACTION || ((((_la - 66) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 66)) & ((1ULL << (ANTLRv4Parser::ACTION_DOT - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_LT - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_GT - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_LPAREN - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_RPAREN - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_LBRACK - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_RBRACK - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_EQUALS - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_COMMA - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_COLON2 - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_COLON - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_MINUS - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_ESCAPE - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_WORD - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_REFERENCE - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_LITERAL - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_TEXT - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_WS - 66))
      | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 66)))) != 0)) {
      setState(253);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx)) {
      case 1: {
        setState(230);
        actionBlock();
        break;
      }

      case 2: {
        setState(231);
        actionExpression();
        break;
      }

      case 3: {
        setState(232);
        actionScopeExpression();
        break;
      }

      case 4: {
        setState(233);
        match(ANTLRv4Parser::ACTION_WS);
        break;
      }

      case 5: {
        setState(234);
        match(ANTLRv4Parser::ACTION_NEWLINE);
        break;
      }

      case 6: {
        setState(235);
        match(ANTLRv4Parser::ACTION_COMMENT);
        break;
      }

      case 7: {
        setState(236);
        match(ANTLRv4Parser::ACTION_LITERAL);
        break;
      }

      case 8: {
        setState(237);
        match(ANTLRv4Parser::ACTION_TEXT);
        break;
      }

      case 9: {
        setState(238);
        match(ANTLRv4Parser::ACTION_LT);
        break;
      }

      case 10: {
        setState(239);
        match(ANTLRv4Parser::ACTION_GT);
        break;
      }

      case 11: {
        setState(240);
        match(ANTLRv4Parser::ACTION_LPAREN);
        break;
      }

      case 12: {
        setState(241);
        match(ANTLRv4Parser::ACTION_RPAREN);
        break;
      }

      case 13: {
        setState(242);
        match(ANTLRv4Parser::ACTION_LBRACK);
        break;
      }

      case 14: {
        setState(243);
        match(ANTLRv4Parser::ACTION_RBRACK);
        break;
      }

      case 15: {
        setState(244);
        match(ANTLRv4Parser::ACTION_EQUALS);
        break;
      }

      case 16: {
        setState(245);
        match(ANTLRv4Parser::ACTION_COMMA);
        break;
      }

      case 17: {
        setState(246);
        match(ANTLRv4Parser::ACTION_ESCAPE);
        break;
      }

      case 18: {
        setState(247);
        match(ANTLRv4Parser::ACTION_WORD);
        break;
      }

      case 19: {
        setState(248);
        match(ANTLRv4Parser::ACTION_REFERENCE);
        break;
      }

      case 20: {
        setState(249);
        match(ANTLRv4Parser::ACTION_COLON);
        break;
      }

      case 21: {
        setState(250);
        match(ANTLRv4Parser::ACTION_COLON2);
        break;
      }

      case 22: {
        setState(251);
        match(ANTLRv4Parser::ACTION_MINUS);
        break;
      }

      case 23: {
        setState(252);
        match(ANTLRv4Parser::ACTION_DOT);
        break;
      }

      }
      setState(257);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(258);
    match(ANTLRv4Parser::END_ACTION);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ActionExpressionContext ------------------------------------------------------------------

ANTLRv4Parser::ActionExpressionContext::ActionExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::ActionExpressionContext::ACTION_REFERENCE() {
  return getToken(ANTLRv4Parser::ACTION_REFERENCE, 0);
}

tree::TerminalNode* ANTLRv4Parser::ActionExpressionContext::ACTION_DOT() {
  return getToken(ANTLRv4Parser::ACTION_DOT, 0);
}

tree::TerminalNode* ANTLRv4Parser::ActionExpressionContext::ACTION_WORD() {
  return getToken(ANTLRv4Parser::ACTION_WORD, 0);
}

std::vector<ANTLRv4Parser::IgnoredContext *> ANTLRv4Parser::ActionExpressionContext::ignored() {
  return getRuleContexts<ANTLRv4Parser::IgnoredContext>();
}

ANTLRv4Parser::IgnoredContext* ANTLRv4Parser::ActionExpressionContext::ignored(size_t i) {
  return getRuleContext<ANTLRv4Parser::IgnoredContext>(i);
}


size_t ANTLRv4Parser::ActionExpressionContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleActionExpression;
}

void ANTLRv4Parser::ActionExpressionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterActionExpression(this);
}

void ANTLRv4Parser::ActionExpressionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitActionExpression(this);
}


antlrcpp::Any ANTLRv4Parser::ActionExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitActionExpression(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ActionExpressionContext* ANTLRv4Parser::actionExpression() {
  ActionExpressionContext *_localctx = _tracker.createInstance<ActionExpressionContext>(_ctx, getState());
  enterRule(_localctx, 20, ANTLRv4Parser::RuleActionExpression);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(260);
    dynamic_cast<ActionExpressionContext *>(_localctx)->ref = match(ANTLRv4Parser::ACTION_REFERENCE);
    setState(264);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (((((_la - 63) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 63)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 63))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_WS - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 63)))) != 0)) {
      setState(261);
      ignored();
      setState(266);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(267);
    dynamic_cast<ActionExpressionContext *>(_localctx)->op = match(ANTLRv4Parser::ACTION_DOT);
    setState(271);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (((((_la - 63) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 63)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 63))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_WS - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 63)))) != 0)) {
      setState(268);
      ignored();
      setState(273);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(274);
    dynamic_cast<ActionExpressionContext *>(_localctx)->member = match(ANTLRv4Parser::ACTION_WORD);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ActionScopeExpressionContext ------------------------------------------------------------------

ANTLRv4Parser::ActionScopeExpressionContext::ActionScopeExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::ActionScopeExpressionContext::ACTION_REFERENCE() {
  return getToken(ANTLRv4Parser::ACTION_REFERENCE, 0);
}

tree::TerminalNode* ANTLRv4Parser::ActionScopeExpressionContext::ACTION_COLON2() {
  return getToken(ANTLRv4Parser::ACTION_COLON2, 0);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ActionScopeExpressionContext::ACTION_WORD() {
  return getTokens(ANTLRv4Parser::ACTION_WORD);
}

tree::TerminalNode* ANTLRv4Parser::ActionScopeExpressionContext::ACTION_WORD(size_t i) {
  return getToken(ANTLRv4Parser::ACTION_WORD, i);
}

std::vector<ANTLRv4Parser::IgnoredContext *> ANTLRv4Parser::ActionScopeExpressionContext::ignored() {
  return getRuleContexts<ANTLRv4Parser::IgnoredContext>();
}

ANTLRv4Parser::IgnoredContext* ANTLRv4Parser::ActionScopeExpressionContext::ignored(size_t i) {
  return getRuleContext<ANTLRv4Parser::IgnoredContext>(i);
}

tree::TerminalNode* ANTLRv4Parser::ActionScopeExpressionContext::ACTION_LBRACK() {
  return getToken(ANTLRv4Parser::ACTION_LBRACK, 0);
}

tree::TerminalNode* ANTLRv4Parser::ActionScopeExpressionContext::ACTION_RBRACK() {
  return getToken(ANTLRv4Parser::ACTION_RBRACK, 0);
}

tree::TerminalNode* ANTLRv4Parser::ActionScopeExpressionContext::ACTION_MINUS() {
  return getToken(ANTLRv4Parser::ACTION_MINUS, 0);
}


size_t ANTLRv4Parser::ActionScopeExpressionContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleActionScopeExpression;
}

void ANTLRv4Parser::ActionScopeExpressionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterActionScopeExpression(this);
}

void ANTLRv4Parser::ActionScopeExpressionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitActionScopeExpression(this);
}


antlrcpp::Any ANTLRv4Parser::ActionScopeExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitActionScopeExpression(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ActionScopeExpressionContext* ANTLRv4Parser::actionScopeExpression() {
  ActionScopeExpressionContext *_localctx = _tracker.createInstance<ActionScopeExpressionContext>(_ctx, getState());
  enterRule(_localctx, 22, ANTLRv4Parser::RuleActionScopeExpression);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(276);
    dynamic_cast<ActionScopeExpressionContext *>(_localctx)->ref = match(ANTLRv4Parser::ACTION_REFERENCE);
    setState(280);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (((((_la - 63) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 63)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 63))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_WS - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 63)))) != 0)) {
      setState(277);
      ignored();
      setState(282);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(313);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == ANTLRv4Parser::ACTION_LBRACK) {
      setState(283);
      match(ANTLRv4Parser::ACTION_LBRACK);
      setState(287);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (((((_la - 63) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 63)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 63))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 63))
        | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 63))
        | (1ULL << (ANTLRv4Parser::ACTION_WS - 63))
        | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 63)))) != 0)) {
        setState(284);
        ignored();
        setState(289);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(297);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == ANTLRv4Parser::ACTION_MINUS) {
        setState(290);
        dynamic_cast<ActionScopeExpressionContext *>(_localctx)->neg = match(ANTLRv4Parser::ACTION_MINUS);
        setState(294);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (((((_la - 63) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 63)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 63))
          | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 63))
          | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 63))
          | (1ULL << (ANTLRv4Parser::ACTION_WS - 63))
          | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 63)))) != 0)) {
          setState(291);
          ignored();
          setState(296);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
      }
      setState(299);
      dynamic_cast<ActionScopeExpressionContext *>(_localctx)->index = match(ANTLRv4Parser::ACTION_WORD);
      setState(303);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (((((_la - 63) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 63)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 63))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 63))
        | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 63))
        | (1ULL << (ANTLRv4Parser::ACTION_WS - 63))
        | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 63)))) != 0)) {
        setState(300);
        ignored();
        setState(305);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(306);
      match(ANTLRv4Parser::ACTION_RBRACK);
      setState(310);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (((((_la - 63) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 63)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 63))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 63))
        | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 63))
        | (1ULL << (ANTLRv4Parser::ACTION_WS - 63))
        | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 63)))) != 0)) {
        setState(307);
        ignored();
        setState(312);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(315);
    dynamic_cast<ActionScopeExpressionContext *>(_localctx)->op = match(ANTLRv4Parser::ACTION_COLON2);
    setState(319);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (((((_la - 63) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 63)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 63))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_WS - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 63)))) != 0)) {
      setState(316);
      ignored();
      setState(321);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(322);
    dynamic_cast<ActionScopeExpressionContext *>(_localctx)->member = match(ANTLRv4Parser::ACTION_WORD);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArgActionBlockContext ------------------------------------------------------------------

ANTLRv4Parser::ArgActionBlockContext::ArgActionBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::ArgActionBlockContext::BEGIN_ARG_ACTION() {
  return getToken(ANTLRv4Parser::BEGIN_ARG_ACTION, 0);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionBlockContext::END_ARG_ACTION() {
  return getToken(ANTLRv4Parser::END_ARG_ACTION, 0);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_ELEMENT() {
  return getTokens(ANTLRv4Parser::ARG_ACTION_ELEMENT);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_ELEMENT(size_t i) {
  return getToken(ANTLRv4Parser::ARG_ACTION_ELEMENT, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_TEXT() {
  return getTokens(ANTLRv4Parser::ARG_ACTION_TEXT);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_TEXT(size_t i) {
  return getToken(ANTLRv4Parser::ARG_ACTION_TEXT, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_LT() {
  return getTokens(ANTLRv4Parser::ARG_ACTION_LT);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_LT(size_t i) {
  return getToken(ANTLRv4Parser::ARG_ACTION_LT, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_GT() {
  return getTokens(ANTLRv4Parser::ARG_ACTION_GT);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_GT(size_t i) {
  return getToken(ANTLRv4Parser::ARG_ACTION_GT, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_LPAREN() {
  return getTokens(ANTLRv4Parser::ARG_ACTION_LPAREN);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_LPAREN(size_t i) {
  return getToken(ANTLRv4Parser::ARG_ACTION_LPAREN, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_RPAREN() {
  return getTokens(ANTLRv4Parser::ARG_ACTION_RPAREN);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_RPAREN(size_t i) {
  return getToken(ANTLRv4Parser::ARG_ACTION_RPAREN, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_EQUALS() {
  return getTokens(ANTLRv4Parser::ARG_ACTION_EQUALS);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_EQUALS(size_t i) {
  return getToken(ANTLRv4Parser::ARG_ACTION_EQUALS, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_COMMA() {
  return getTokens(ANTLRv4Parser::ARG_ACTION_COMMA);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_COMMA(size_t i) {
  return getToken(ANTLRv4Parser::ARG_ACTION_COMMA, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_ESCAPE() {
  return getTokens(ANTLRv4Parser::ARG_ACTION_ESCAPE);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_ESCAPE(size_t i) {
  return getToken(ANTLRv4Parser::ARG_ACTION_ESCAPE, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_WORD() {
  return getTokens(ANTLRv4Parser::ARG_ACTION_WORD);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_WORD(size_t i) {
  return getToken(ANTLRv4Parser::ARG_ACTION_WORD, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_WS() {
  return getTokens(ANTLRv4Parser::ARG_ACTION_WS);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_WS(size_t i) {
  return getToken(ANTLRv4Parser::ARG_ACTION_WS, i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_NEWLINE() {
  return getTokens(ANTLRv4Parser::ARG_ACTION_NEWLINE);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionBlockContext::ARG_ACTION_NEWLINE(size_t i) {
  return getToken(ANTLRv4Parser::ARG_ACTION_NEWLINE, i);
}


size_t ANTLRv4Parser::ArgActionBlockContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleArgActionBlock;
}

void ANTLRv4Parser::ArgActionBlockContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterArgActionBlock(this);
}

void ANTLRv4Parser::ArgActionBlockContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitArgActionBlock(this);
}


antlrcpp::Any ANTLRv4Parser::ArgActionBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitArgActionBlock(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ArgActionBlockContext* ANTLRv4Parser::argActionBlock() {
  ArgActionBlockContext *_localctx = _tracker.createInstance<ArgActionBlockContext>(_ctx, getState());
  enterRule(_localctx, 24, ANTLRv4Parser::RuleArgActionBlock);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(324);
    match(ANTLRv4Parser::BEGIN_ARG_ACTION);
    setState(328);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (((((_la - 53) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 53)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_LT - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_GT - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_LPAREN - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_RPAREN - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_EQUALS - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_COMMA - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_ESCAPE - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_WORD - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_ELEMENT - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_TEXT - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 53)))) != 0)) {
      setState(325);
      _la = _input->LA(1);
      if (!(((((_la - 53) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 53)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_LT - 53))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_GT - 53))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_LPAREN - 53))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_RPAREN - 53))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_EQUALS - 53))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_COMMA - 53))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_ESCAPE - 53))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_WORD - 53))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_ELEMENT - 53))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_TEXT - 53))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 53))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 53)))) != 0))) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(330);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(331);
    match(ANTLRv4Parser::END_ARG_ACTION);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArgActionParametersContext ------------------------------------------------------------------

ANTLRv4Parser::ArgActionParametersContext::ArgActionParametersContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::ArgActionParametersContext::BEGIN_ARG_ACTION() {
  return getToken(ANTLRv4Parser::BEGIN_ARG_ACTION, 0);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionParametersContext::END_ARG_ACTION() {
  return getToken(ANTLRv4Parser::END_ARG_ACTION, 0);
}

std::vector<ANTLRv4Parser::IgnoredContext *> ANTLRv4Parser::ArgActionParametersContext::ignored() {
  return getRuleContexts<ANTLRv4Parser::IgnoredContext>();
}

ANTLRv4Parser::IgnoredContext* ANTLRv4Parser::ArgActionParametersContext::ignored(size_t i) {
  return getRuleContext<ANTLRv4Parser::IgnoredContext>(i);
}

std::vector<ANTLRv4Parser::ArgActionParameterContext *> ANTLRv4Parser::ArgActionParametersContext::argActionParameter() {
  return getRuleContexts<ANTLRv4Parser::ArgActionParameterContext>();
}

ANTLRv4Parser::ArgActionParameterContext* ANTLRv4Parser::ArgActionParametersContext::argActionParameter(size_t i) {
  return getRuleContext<ANTLRv4Parser::ArgActionParameterContext>(i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ArgActionParametersContext::ARG_ACTION_COMMA() {
  return getTokens(ANTLRv4Parser::ARG_ACTION_COMMA);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionParametersContext::ARG_ACTION_COMMA(size_t i) {
  return getToken(ANTLRv4Parser::ARG_ACTION_COMMA, i);
}


size_t ANTLRv4Parser::ArgActionParametersContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleArgActionParameters;
}

void ANTLRv4Parser::ArgActionParametersContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterArgActionParameters(this);
}

void ANTLRv4Parser::ArgActionParametersContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitArgActionParameters(this);
}


antlrcpp::Any ANTLRv4Parser::ArgActionParametersContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitArgActionParameters(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ArgActionParametersContext* ANTLRv4Parser::argActionParameters() {
  ArgActionParametersContext *_localctx = _tracker.createInstance<ArgActionParametersContext>(_ctx, getState());
  enterRule(_localctx, 26, ANTLRv4Parser::RuleArgActionParameters);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(333);
    match(ANTLRv4Parser::BEGIN_ARG_ACTION);
    setState(337);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 24, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(334);
        ignored(); 
      }
      setState(339);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 24, _ctx);
    }
    setState(366);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((((_la - 53) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 53)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_LT - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_LPAREN - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_WORD - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 53))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 53))
      | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 53))
      | (1ULL << (ANTLRv4Parser::ACTION_WS - 53))
      | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 53)))) != 0)) {
      setState(340);
      dynamic_cast<ArgActionParametersContext *>(_localctx)->argActionParameterContext = argActionParameter();
      dynamic_cast<ArgActionParametersContext *>(_localctx)->parameters.push_back(dynamic_cast<ArgActionParametersContext *>(_localctx)->argActionParameterContext);
      setState(344);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (((((_la - 63) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 63)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 63))
        | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 63))
        | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 63))
        | (1ULL << (ANTLRv4Parser::ACTION_WS - 63))
        | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 63)))) != 0)) {
        setState(341);
        ignored();
        setState(346);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(363);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == ANTLRv4Parser::ARG_ACTION_COMMA) {
        setState(347);
        match(ANTLRv4Parser::ARG_ACTION_COMMA);
        setState(351);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 26, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(348);
            ignored(); 
          }
          setState(353);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 26, _ctx);
        }
        setState(354);
        dynamic_cast<ArgActionParametersContext *>(_localctx)->argActionParameterContext = argActionParameter();
        dynamic_cast<ArgActionParametersContext *>(_localctx)->parameters.push_back(dynamic_cast<ArgActionParametersContext *>(_localctx)->argActionParameterContext);
        setState(358);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (((((_la - 63) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 63)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 63))
          | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 63))
          | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 63))
          | (1ULL << (ANTLRv4Parser::ACTION_WS - 63))
          | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 63)))) != 0)) {
          setState(355);
          ignored();
          setState(360);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(365);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(368);
    match(ANTLRv4Parser::END_ARG_ACTION);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArgActionParameterContext ------------------------------------------------------------------

ANTLRv4Parser::ArgActionParameterContext::ArgActionParameterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::ArgActionParameterContext::ARG_ACTION_WORD() {
  return getToken(ANTLRv4Parser::ARG_ACTION_WORD, 0);
}

std::vector<ANTLRv4Parser::IgnoredContext *> ANTLRv4Parser::ArgActionParameterContext::ignored() {
  return getRuleContexts<ANTLRv4Parser::IgnoredContext>();
}

ANTLRv4Parser::IgnoredContext* ANTLRv4Parser::ArgActionParameterContext::ignored(size_t i) {
  return getRuleContext<ANTLRv4Parser::IgnoredContext>(i);
}

ANTLRv4Parser::ArgActionParameterTypeContext* ANTLRv4Parser::ArgActionParameterContext::argActionParameterType() {
  return getRuleContext<ANTLRv4Parser::ArgActionParameterTypeContext>(0);
}


size_t ANTLRv4Parser::ArgActionParameterContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleArgActionParameter;
}

void ANTLRv4Parser::ArgActionParameterContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterArgActionParameter(this);
}

void ANTLRv4Parser::ArgActionParameterContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitArgActionParameter(this);
}


antlrcpp::Any ANTLRv4Parser::ArgActionParameterContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitArgActionParameter(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ArgActionParameterContext* ANTLRv4Parser::argActionParameter() {
  ArgActionParameterContext *_localctx = _tracker.createInstance<ArgActionParameterContext>(_ctx, getState());
  enterRule(_localctx, 28, ANTLRv4Parser::RuleArgActionParameter);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(371);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 30, _ctx)) {
    case 1: {
      setState(370);
      dynamic_cast<ArgActionParameterContext *>(_localctx)->type = argActionParameterType();
      break;
    }

    }
    setState(376);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (((((_la - 63) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 63)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 63))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_WS - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 63)))) != 0)) {
      setState(373);
      ignored();
      setState(378);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(379);
    dynamic_cast<ArgActionParameterContext *>(_localctx)->name = match(ANTLRv4Parser::ARG_ACTION_WORD);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArgActionParameterTypeContext ------------------------------------------------------------------

ANTLRv4Parser::ArgActionParameterTypeContext::ArgActionParameterTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<ANTLRv4Parser::ArgActionParameterTypePartContext *> ANTLRv4Parser::ArgActionParameterTypeContext::argActionParameterTypePart() {
  return getRuleContexts<ANTLRv4Parser::ArgActionParameterTypePartContext>();
}

ANTLRv4Parser::ArgActionParameterTypePartContext* ANTLRv4Parser::ArgActionParameterTypeContext::argActionParameterTypePart(size_t i) {
  return getRuleContext<ANTLRv4Parser::ArgActionParameterTypePartContext>(i);
}

std::vector<ANTLRv4Parser::IgnoredContext *> ANTLRv4Parser::ArgActionParameterTypeContext::ignored() {
  return getRuleContexts<ANTLRv4Parser::IgnoredContext>();
}

ANTLRv4Parser::IgnoredContext* ANTLRv4Parser::ArgActionParameterTypeContext::ignored(size_t i) {
  return getRuleContext<ANTLRv4Parser::IgnoredContext>(i);
}


size_t ANTLRv4Parser::ArgActionParameterTypeContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleArgActionParameterType;
}

void ANTLRv4Parser::ArgActionParameterTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterArgActionParameterType(this);
}

void ANTLRv4Parser::ArgActionParameterTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitArgActionParameterType(this);
}


antlrcpp::Any ANTLRv4Parser::ArgActionParameterTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitArgActionParameterType(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ArgActionParameterTypeContext* ANTLRv4Parser::argActionParameterType() {
  ArgActionParameterTypeContext *_localctx = _tracker.createInstance<ArgActionParameterTypeContext>(_ctx, getState());
  enterRule(_localctx, 30, ANTLRv4Parser::RuleArgActionParameterType);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(381);
    argActionParameterTypePart();
    setState(391);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 33, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(385);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (((((_la - 63) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 63)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 63))
          | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 63))
          | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 63))
          | (1ULL << (ANTLRv4Parser::ACTION_WS - 63))
          | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 63)))) != 0)) {
          setState(382);
          ignored();
          setState(387);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(388);
        argActionParameterTypePart(); 
      }
      setState(393);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 33, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArgActionParameterTypePartContext ------------------------------------------------------------------

ANTLRv4Parser::ArgActionParameterTypePartContext::ArgActionParameterTypePartContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::ArgActionParameterTypePartContext::ARG_ACTION_WORD() {
  return getToken(ANTLRv4Parser::ARG_ACTION_WORD, 0);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionParameterTypePartContext::ARG_ACTION_LT() {
  return getToken(ANTLRv4Parser::ARG_ACTION_LT, 0);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionParameterTypePartContext::ARG_ACTION_GT() {
  return getToken(ANTLRv4Parser::ARG_ACTION_GT, 0);
}

ANTLRv4Parser::ArgActionParameterTypeContext* ANTLRv4Parser::ArgActionParameterTypePartContext::argActionParameterType() {
  return getRuleContext<ANTLRv4Parser::ArgActionParameterTypeContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionParameterTypePartContext::ARG_ACTION_LPAREN() {
  return getToken(ANTLRv4Parser::ARG_ACTION_LPAREN, 0);
}

tree::TerminalNode* ANTLRv4Parser::ArgActionParameterTypePartContext::ARG_ACTION_RPAREN() {
  return getToken(ANTLRv4Parser::ARG_ACTION_RPAREN, 0);
}


size_t ANTLRv4Parser::ArgActionParameterTypePartContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleArgActionParameterTypePart;
}

void ANTLRv4Parser::ArgActionParameterTypePartContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterArgActionParameterTypePart(this);
}

void ANTLRv4Parser::ArgActionParameterTypePartContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitArgActionParameterTypePart(this);
}


antlrcpp::Any ANTLRv4Parser::ArgActionParameterTypePartContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitArgActionParameterTypePart(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ArgActionParameterTypePartContext* ANTLRv4Parser::argActionParameterTypePart() {
  ArgActionParameterTypePartContext *_localctx = _tracker.createInstance<ArgActionParameterTypePartContext>(_ctx, getState());
  enterRule(_localctx, 32, ANTLRv4Parser::RuleArgActionParameterTypePart);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(405);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case ANTLRv4Parser::ARG_ACTION_WORD: {
        enterOuterAlt(_localctx, 1);
        setState(394);
        match(ANTLRv4Parser::ARG_ACTION_WORD);
        break;
      }

      case ANTLRv4Parser::ARG_ACTION_LT: {
        enterOuterAlt(_localctx, 2);
        setState(395);
        match(ANTLRv4Parser::ARG_ACTION_LT);
        setState(397);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if ((((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & ((1ULL << ANTLRv4Parser::ARG_ACTION_LT)
          | (1ULL << ANTLRv4Parser::ARG_ACTION_LPAREN)
          | (1ULL << ANTLRv4Parser::ARG_ACTION_WORD))) != 0)) {
          setState(396);
          argActionParameterType();
        }
        setState(399);
        match(ANTLRv4Parser::ARG_ACTION_GT);
        break;
      }

      case ANTLRv4Parser::ARG_ACTION_LPAREN: {
        enterOuterAlt(_localctx, 3);
        setState(400);
        match(ANTLRv4Parser::ARG_ACTION_LPAREN);
        setState(402);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if ((((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & ((1ULL << ANTLRv4Parser::ARG_ACTION_LT)
          | (1ULL << ANTLRv4Parser::ARG_ACTION_LPAREN)
          | (1ULL << ANTLRv4Parser::ARG_ACTION_WORD))) != 0)) {
          setState(401);
          argActionParameterType();
        }
        setState(404);
        match(ANTLRv4Parser::ARG_ACTION_RPAREN);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IgnoredContext ------------------------------------------------------------------

ANTLRv4Parser::IgnoredContext::IgnoredContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::IgnoredContext::ACTION_WS() {
  return getToken(ANTLRv4Parser::ACTION_WS, 0);
}

tree::TerminalNode* ANTLRv4Parser::IgnoredContext::ACTION_NEWLINE() {
  return getToken(ANTLRv4Parser::ACTION_NEWLINE, 0);
}

tree::TerminalNode* ANTLRv4Parser::IgnoredContext::ACTION_COMMENT() {
  return getToken(ANTLRv4Parser::ACTION_COMMENT, 0);
}

tree::TerminalNode* ANTLRv4Parser::IgnoredContext::ARG_ACTION_WS() {
  return getToken(ANTLRv4Parser::ARG_ACTION_WS, 0);
}

tree::TerminalNode* ANTLRv4Parser::IgnoredContext::ARG_ACTION_NEWLINE() {
  return getToken(ANTLRv4Parser::ARG_ACTION_NEWLINE, 0);
}


size_t ANTLRv4Parser::IgnoredContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleIgnored;
}

void ANTLRv4Parser::IgnoredContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIgnored(this);
}

void ANTLRv4Parser::IgnoredContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIgnored(this);
}


antlrcpp::Any ANTLRv4Parser::IgnoredContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitIgnored(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::IgnoredContext* ANTLRv4Parser::ignored() {
  IgnoredContext *_localctx = _tracker.createInstance<IgnoredContext>(_ctx, getState());
  enterRule(_localctx, 34, ANTLRv4Parser::RuleIgnored);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(407);
    _la = _input->LA(1);
    if (!(((((_la - 63) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 63)) & ((1ULL << (ANTLRv4Parser::ARG_ACTION_WS - 63))
      | (1ULL << (ANTLRv4Parser::ARG_ACTION_NEWLINE - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_COMMENT - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_WS - 63))
      | (1ULL << (ANTLRv4Parser::ACTION_NEWLINE - 63)))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ActionContext ------------------------------------------------------------------

ANTLRv4Parser::ActionContext::ActionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::ActionContext::AT() {
  return getToken(ANTLRv4Parser::AT, 0);
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::ActionContext::id() {
  return getRuleContext<ANTLRv4Parser::IdContext>(0);
}

ANTLRv4Parser::ActionBlockContext* ANTLRv4Parser::ActionContext::actionBlock() {
  return getRuleContext<ANTLRv4Parser::ActionBlockContext>(0);
}

ANTLRv4Parser::ActionScopeNameContext* ANTLRv4Parser::ActionContext::actionScopeName() {
  return getRuleContext<ANTLRv4Parser::ActionScopeNameContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::ActionContext::COLONCOLON() {
  return getToken(ANTLRv4Parser::COLONCOLON, 0);
}


size_t ANTLRv4Parser::ActionContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleAction;
}

void ANTLRv4Parser::ActionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAction(this);
}

void ANTLRv4Parser::ActionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAction(this);
}


antlrcpp::Any ANTLRv4Parser::ActionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitAction(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ActionContext* ANTLRv4Parser::action() {
  ActionContext *_localctx = _tracker.createInstance<ActionContext>(_ctx, getState());
  enterRule(_localctx, 36, ANTLRv4Parser::RuleAction);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(409);
    match(ANTLRv4Parser::AT);
    setState(413);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 37, _ctx)) {
    case 1: {
      setState(410);
      actionScopeName();
      setState(411);
      match(ANTLRv4Parser::COLONCOLON);
      break;
    }

    }
    setState(415);
    id();
    setState(416);
    actionBlock();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ActionScopeNameContext ------------------------------------------------------------------

ANTLRv4Parser::ActionScopeNameContext::ActionScopeNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::ActionScopeNameContext::id() {
  return getRuleContext<ANTLRv4Parser::IdContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::ActionScopeNameContext::LEXER() {
  return getToken(ANTLRv4Parser::LEXER, 0);
}

tree::TerminalNode* ANTLRv4Parser::ActionScopeNameContext::PARSER() {
  return getToken(ANTLRv4Parser::PARSER, 0);
}


size_t ANTLRv4Parser::ActionScopeNameContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleActionScopeName;
}

void ANTLRv4Parser::ActionScopeNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterActionScopeName(this);
}

void ANTLRv4Parser::ActionScopeNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitActionScopeName(this);
}


antlrcpp::Any ANTLRv4Parser::ActionScopeNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitActionScopeName(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ActionScopeNameContext* ANTLRv4Parser::actionScopeName() {
  ActionScopeNameContext *_localctx = _tracker.createInstance<ActionScopeNameContext>(_ctx, getState());
  enterRule(_localctx, 38, ANTLRv4Parser::RuleActionScopeName);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(421);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case ANTLRv4Parser::TOKEN_REF:
      case ANTLRv4Parser::RULE_REF: {
        enterOuterAlt(_localctx, 1);
        setState(418);
        id();
        break;
      }

      case ANTLRv4Parser::LEXER: {
        enterOuterAlt(_localctx, 2);
        setState(419);
        match(ANTLRv4Parser::LEXER);
        break;
      }

      case ANTLRv4Parser::PARSER: {
        enterOuterAlt(_localctx, 3);
        setState(420);
        match(ANTLRv4Parser::PARSER);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ModeSpecContext ------------------------------------------------------------------

ANTLRv4Parser::ModeSpecContext::ModeSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::ModeSpecContext::MODE() {
  return getToken(ANTLRv4Parser::MODE, 0);
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::ModeSpecContext::id() {
  return getRuleContext<ANTLRv4Parser::IdContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::ModeSpecContext::SEMI() {
  return getToken(ANTLRv4Parser::SEMI, 0);
}

std::vector<ANTLRv4Parser::RuleSpecContext *> ANTLRv4Parser::ModeSpecContext::ruleSpec() {
  return getRuleContexts<ANTLRv4Parser::RuleSpecContext>();
}

ANTLRv4Parser::RuleSpecContext* ANTLRv4Parser::ModeSpecContext::ruleSpec(size_t i) {
  return getRuleContext<ANTLRv4Parser::RuleSpecContext>(i);
}


size_t ANTLRv4Parser::ModeSpecContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleModeSpec;
}

void ANTLRv4Parser::ModeSpecContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterModeSpec(this);
}

void ANTLRv4Parser::ModeSpecContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitModeSpec(this);
}


antlrcpp::Any ANTLRv4Parser::ModeSpecContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitModeSpec(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ModeSpecContext* ANTLRv4Parser::modeSpec() {
  ModeSpecContext *_localctx = _tracker.createInstance<ModeSpecContext>(_ctx, getState());
  enterRule(_localctx, 40, ANTLRv4Parser::RuleModeSpec);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(423);
    match(ANTLRv4Parser::MODE);
    setState(424);
    id();
    setState(425);
    match(ANTLRv4Parser::SEMI);
    setState(427); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(426);
      ruleSpec();
      setState(429); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << ANTLRv4Parser::TOKEN_REF)
      | (1ULL << ANTLRv4Parser::RULE_REF)
      | (1ULL << ANTLRv4Parser::DOC_COMMENT)
      | (1ULL << ANTLRv4Parser::FRAGMENT)
      | (1ULL << ANTLRv4Parser::PROTECTED)
      | (1ULL << ANTLRv4Parser::PUBLIC)
      | (1ULL << ANTLRv4Parser::PRIVATE))) != 0));
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RulesContext ------------------------------------------------------------------

ANTLRv4Parser::RulesContext::RulesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<ANTLRv4Parser::RuleSpecContext *> ANTLRv4Parser::RulesContext::ruleSpec() {
  return getRuleContexts<ANTLRv4Parser::RuleSpecContext>();
}

ANTLRv4Parser::RuleSpecContext* ANTLRv4Parser::RulesContext::ruleSpec(size_t i) {
  return getRuleContext<ANTLRv4Parser::RuleSpecContext>(i);
}


size_t ANTLRv4Parser::RulesContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleRules;
}

void ANTLRv4Parser::RulesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRules(this);
}

void ANTLRv4Parser::RulesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRules(this);
}


antlrcpp::Any ANTLRv4Parser::RulesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitRules(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::RulesContext* ANTLRv4Parser::rules() {
  RulesContext *_localctx = _tracker.createInstance<RulesContext>(_ctx, getState());
  enterRule(_localctx, 42, ANTLRv4Parser::RuleRules);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(434);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << ANTLRv4Parser::TOKEN_REF)
      | (1ULL << ANTLRv4Parser::RULE_REF)
      | (1ULL << ANTLRv4Parser::DOC_COMMENT)
      | (1ULL << ANTLRv4Parser::FRAGMENT)
      | (1ULL << ANTLRv4Parser::PROTECTED)
      | (1ULL << ANTLRv4Parser::PUBLIC)
      | (1ULL << ANTLRv4Parser::PRIVATE))) != 0)) {
      setState(431);
      ruleSpec();
      setState(436);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RuleSpecContext ------------------------------------------------------------------

ANTLRv4Parser::RuleSpecContext::RuleSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::ParserRuleSpecContext* ANTLRv4Parser::RuleSpecContext::parserRuleSpec() {
  return getRuleContext<ANTLRv4Parser::ParserRuleSpecContext>(0);
}

ANTLRv4Parser::LexerRuleContext* ANTLRv4Parser::RuleSpecContext::lexerRule() {
  return getRuleContext<ANTLRv4Parser::LexerRuleContext>(0);
}


size_t ANTLRv4Parser::RuleSpecContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleRuleSpec;
}

void ANTLRv4Parser::RuleSpecContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRuleSpec(this);
}

void ANTLRv4Parser::RuleSpecContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRuleSpec(this);
}


antlrcpp::Any ANTLRv4Parser::RuleSpecContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitRuleSpec(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::RuleSpecContext* ANTLRv4Parser::ruleSpec() {
  RuleSpecContext *_localctx = _tracker.createInstance<RuleSpecContext>(_ctx, getState());
  enterRule(_localctx, 44, ANTLRv4Parser::RuleRuleSpec);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(439);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 41, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(437);
      parserRuleSpec();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(438);
      lexerRule();
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ParserRuleSpecContext ------------------------------------------------------------------

ANTLRv4Parser::ParserRuleSpecContext::ParserRuleSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::RulePrequelsContext* ANTLRv4Parser::ParserRuleSpecContext::rulePrequels() {
  return getRuleContext<ANTLRv4Parser::RulePrequelsContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::ParserRuleSpecContext::COLON() {
  return getToken(ANTLRv4Parser::COLON, 0);
}

ANTLRv4Parser::RuleBlockContext* ANTLRv4Parser::ParserRuleSpecContext::ruleBlock() {
  return getRuleContext<ANTLRv4Parser::RuleBlockContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::ParserRuleSpecContext::SEMI() {
  return getToken(ANTLRv4Parser::SEMI, 0);
}

ANTLRv4Parser::ExceptionGroupContext* ANTLRv4Parser::ParserRuleSpecContext::exceptionGroup() {
  return getRuleContext<ANTLRv4Parser::ExceptionGroupContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::ParserRuleSpecContext::RULE_REF() {
  return getToken(ANTLRv4Parser::RULE_REF, 0);
}

tree::TerminalNode* ANTLRv4Parser::ParserRuleSpecContext::DOC_COMMENT() {
  return getToken(ANTLRv4Parser::DOC_COMMENT, 0);
}

ANTLRv4Parser::RuleModifiersContext* ANTLRv4Parser::ParserRuleSpecContext::ruleModifiers() {
  return getRuleContext<ANTLRv4Parser::RuleModifiersContext>(0);
}

ANTLRv4Parser::ArgActionParametersContext* ANTLRv4Parser::ParserRuleSpecContext::argActionParameters() {
  return getRuleContext<ANTLRv4Parser::ArgActionParametersContext>(0);
}

ANTLRv4Parser::RuleReturnsContext* ANTLRv4Parser::ParserRuleSpecContext::ruleReturns() {
  return getRuleContext<ANTLRv4Parser::RuleReturnsContext>(0);
}

ANTLRv4Parser::ThrowsSpecContext* ANTLRv4Parser::ParserRuleSpecContext::throwsSpec() {
  return getRuleContext<ANTLRv4Parser::ThrowsSpecContext>(0);
}

ANTLRv4Parser::LocalsSpecContext* ANTLRv4Parser::ParserRuleSpecContext::localsSpec() {
  return getRuleContext<ANTLRv4Parser::LocalsSpecContext>(0);
}


size_t ANTLRv4Parser::ParserRuleSpecContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleParserRuleSpec;
}

void ANTLRv4Parser::ParserRuleSpecContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterParserRuleSpec(this);
}

void ANTLRv4Parser::ParserRuleSpecContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitParserRuleSpec(this);
}


antlrcpp::Any ANTLRv4Parser::ParserRuleSpecContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitParserRuleSpec(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ParserRuleSpecContext* ANTLRv4Parser::parserRuleSpec() {
  ParserRuleSpecContext *_localctx = _tracker.createInstance<ParserRuleSpecContext>(_ctx, getState());
  enterRule(_localctx, 46, ANTLRv4Parser::RuleParserRuleSpec);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(442);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == ANTLRv4Parser::DOC_COMMENT) {
      setState(441);
      match(ANTLRv4Parser::DOC_COMMENT);
    }
    setState(445);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << ANTLRv4Parser::FRAGMENT)
      | (1ULL << ANTLRv4Parser::PROTECTED)
      | (1ULL << ANTLRv4Parser::PUBLIC)
      | (1ULL << ANTLRv4Parser::PRIVATE))) != 0)) {
      setState(444);
      ruleModifiers();
    }
    setState(447);
    dynamic_cast<ParserRuleSpecContext *>(_localctx)->name = match(ANTLRv4Parser::RULE_REF);
    setState(449);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == ANTLRv4Parser::BEGIN_ARG_ACTION) {
      setState(448);
      argActionParameters();
    }
    setState(452);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == ANTLRv4Parser::RETURNS) {
      setState(451);
      ruleReturns();
    }
    setState(455);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == ANTLRv4Parser::THROWS) {
      setState(454);
      throwsSpec();
    }
    setState(458);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == ANTLRv4Parser::LOCALS) {
      setState(457);
      localsSpec();
    }
    setState(460);
    rulePrequels();
    setState(461);
    match(ANTLRv4Parser::COLON);
    setState(462);
    ruleBlock();
    setState(463);
    match(ANTLRv4Parser::SEMI);
    setState(464);
    exceptionGroup();

    			this->findParserRule(_localctx);
    		
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExceptionGroupContext ------------------------------------------------------------------

ANTLRv4Parser::ExceptionGroupContext::ExceptionGroupContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<ANTLRv4Parser::ExceptionHandlerContext *> ANTLRv4Parser::ExceptionGroupContext::exceptionHandler() {
  return getRuleContexts<ANTLRv4Parser::ExceptionHandlerContext>();
}

ANTLRv4Parser::ExceptionHandlerContext* ANTLRv4Parser::ExceptionGroupContext::exceptionHandler(size_t i) {
  return getRuleContext<ANTLRv4Parser::ExceptionHandlerContext>(i);
}

ANTLRv4Parser::FinallyClauseContext* ANTLRv4Parser::ExceptionGroupContext::finallyClause() {
  return getRuleContext<ANTLRv4Parser::FinallyClauseContext>(0);
}


size_t ANTLRv4Parser::ExceptionGroupContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleExceptionGroup;
}

void ANTLRv4Parser::ExceptionGroupContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExceptionGroup(this);
}

void ANTLRv4Parser::ExceptionGroupContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExceptionGroup(this);
}


antlrcpp::Any ANTLRv4Parser::ExceptionGroupContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitExceptionGroup(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ExceptionGroupContext* ANTLRv4Parser::exceptionGroup() {
  ExceptionGroupContext *_localctx = _tracker.createInstance<ExceptionGroupContext>(_ctx, getState());
  enterRule(_localctx, 48, ANTLRv4Parser::RuleExceptionGroup);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(470);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == ANTLRv4Parser::CATCH) {
      setState(467);
      exceptionHandler();
      setState(472);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(474);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == ANTLRv4Parser::FINALLY) {
      setState(473);
      finallyClause();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExceptionHandlerContext ------------------------------------------------------------------

ANTLRv4Parser::ExceptionHandlerContext::ExceptionHandlerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::ExceptionHandlerContext::CATCH() {
  return getToken(ANTLRv4Parser::CATCH, 0);
}

ANTLRv4Parser::ArgActionBlockContext* ANTLRv4Parser::ExceptionHandlerContext::argActionBlock() {
  return getRuleContext<ANTLRv4Parser::ArgActionBlockContext>(0);
}

ANTLRv4Parser::ActionBlockContext* ANTLRv4Parser::ExceptionHandlerContext::actionBlock() {
  return getRuleContext<ANTLRv4Parser::ActionBlockContext>(0);
}


size_t ANTLRv4Parser::ExceptionHandlerContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleExceptionHandler;
}

void ANTLRv4Parser::ExceptionHandlerContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExceptionHandler(this);
}

void ANTLRv4Parser::ExceptionHandlerContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExceptionHandler(this);
}


antlrcpp::Any ANTLRv4Parser::ExceptionHandlerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitExceptionHandler(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ExceptionHandlerContext* ANTLRv4Parser::exceptionHandler() {
  ExceptionHandlerContext *_localctx = _tracker.createInstance<ExceptionHandlerContext>(_ctx, getState());
  enterRule(_localctx, 50, ANTLRv4Parser::RuleExceptionHandler);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(476);
    match(ANTLRv4Parser::CATCH);
    setState(477);
    argActionBlock();
    setState(478);
    actionBlock();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FinallyClauseContext ------------------------------------------------------------------

ANTLRv4Parser::FinallyClauseContext::FinallyClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::FinallyClauseContext::FINALLY() {
  return getToken(ANTLRv4Parser::FINALLY, 0);
}

ANTLRv4Parser::ActionBlockContext* ANTLRv4Parser::FinallyClauseContext::actionBlock() {
  return getRuleContext<ANTLRv4Parser::ActionBlockContext>(0);
}


size_t ANTLRv4Parser::FinallyClauseContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleFinallyClause;
}

void ANTLRv4Parser::FinallyClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFinallyClause(this);
}

void ANTLRv4Parser::FinallyClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFinallyClause(this);
}


antlrcpp::Any ANTLRv4Parser::FinallyClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitFinallyClause(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::FinallyClauseContext* ANTLRv4Parser::finallyClause() {
  FinallyClauseContext *_localctx = _tracker.createInstance<FinallyClauseContext>(_ctx, getState());
  enterRule(_localctx, 52, ANTLRv4Parser::RuleFinallyClause);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(480);
    match(ANTLRv4Parser::FINALLY);
    setState(481);
    actionBlock();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RulePrequelsContext ------------------------------------------------------------------

ANTLRv4Parser::RulePrequelsContext::RulePrequelsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<ANTLRv4Parser::RulePrequelContext *> ANTLRv4Parser::RulePrequelsContext::rulePrequel() {
  return getRuleContexts<ANTLRv4Parser::RulePrequelContext>();
}

ANTLRv4Parser::RulePrequelContext* ANTLRv4Parser::RulePrequelsContext::rulePrequel(size_t i) {
  return getRuleContext<ANTLRv4Parser::RulePrequelContext>(i);
}


size_t ANTLRv4Parser::RulePrequelsContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleRulePrequels;
}

void ANTLRv4Parser::RulePrequelsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRulePrequels(this);
}

void ANTLRv4Parser::RulePrequelsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRulePrequels(this);
}


antlrcpp::Any ANTLRv4Parser::RulePrequelsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitRulePrequels(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::RulePrequelsContext* ANTLRv4Parser::rulePrequels() {
  RulePrequelsContext *_localctx = _tracker.createInstance<RulePrequelsContext>(_ctx, getState());
  enterRule(_localctx, 54, ANTLRv4Parser::RuleRulePrequels);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(486);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == ANTLRv4Parser::OPTIONS

    || _la == ANTLRv4Parser::AT) {
      setState(483);
      rulePrequel();
      setState(488);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RulePrequelContext ------------------------------------------------------------------

ANTLRv4Parser::RulePrequelContext::RulePrequelContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::OptionsSpecContext* ANTLRv4Parser::RulePrequelContext::optionsSpec() {
  return getRuleContext<ANTLRv4Parser::OptionsSpecContext>(0);
}

ANTLRv4Parser::RuleActionContext* ANTLRv4Parser::RulePrequelContext::ruleAction() {
  return getRuleContext<ANTLRv4Parser::RuleActionContext>(0);
}


size_t ANTLRv4Parser::RulePrequelContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleRulePrequel;
}

void ANTLRv4Parser::RulePrequelContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRulePrequel(this);
}

void ANTLRv4Parser::RulePrequelContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRulePrequel(this);
}


antlrcpp::Any ANTLRv4Parser::RulePrequelContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitRulePrequel(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::RulePrequelContext* ANTLRv4Parser::rulePrequel() {
  RulePrequelContext *_localctx = _tracker.createInstance<RulePrequelContext>(_ctx, getState());
  enterRule(_localctx, 56, ANTLRv4Parser::RuleRulePrequel);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(491);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case ANTLRv4Parser::OPTIONS: {
        enterOuterAlt(_localctx, 1);
        setState(489);
        optionsSpec();
        break;
      }

      case ANTLRv4Parser::AT: {
        enterOuterAlt(_localctx, 2);
        setState(490);
        ruleAction();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RuleReturnsContext ------------------------------------------------------------------

ANTLRv4Parser::RuleReturnsContext::RuleReturnsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::RuleReturnsContext::RETURNS() {
  return getToken(ANTLRv4Parser::RETURNS, 0);
}

ANTLRv4Parser::ArgActionParametersContext* ANTLRv4Parser::RuleReturnsContext::argActionParameters() {
  return getRuleContext<ANTLRv4Parser::ArgActionParametersContext>(0);
}


size_t ANTLRv4Parser::RuleReturnsContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleRuleReturns;
}

void ANTLRv4Parser::RuleReturnsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRuleReturns(this);
}

void ANTLRv4Parser::RuleReturnsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRuleReturns(this);
}


antlrcpp::Any ANTLRv4Parser::RuleReturnsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitRuleReturns(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::RuleReturnsContext* ANTLRv4Parser::ruleReturns() {
  RuleReturnsContext *_localctx = _tracker.createInstance<RuleReturnsContext>(_ctx, getState());
  enterRule(_localctx, 58, ANTLRv4Parser::RuleRuleReturns);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(493);
    match(ANTLRv4Parser::RETURNS);
    setState(494);
    argActionParameters();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ThrowsSpecContext ------------------------------------------------------------------

ANTLRv4Parser::ThrowsSpecContext::ThrowsSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::ThrowsSpecContext::THROWS() {
  return getToken(ANTLRv4Parser::THROWS, 0);
}

std::vector<ANTLRv4Parser::QidContext *> ANTLRv4Parser::ThrowsSpecContext::qid() {
  return getRuleContexts<ANTLRv4Parser::QidContext>();
}

ANTLRv4Parser::QidContext* ANTLRv4Parser::ThrowsSpecContext::qid(size_t i) {
  return getRuleContext<ANTLRv4Parser::QidContext>(i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ThrowsSpecContext::COMMA() {
  return getTokens(ANTLRv4Parser::COMMA);
}

tree::TerminalNode* ANTLRv4Parser::ThrowsSpecContext::COMMA(size_t i) {
  return getToken(ANTLRv4Parser::COMMA, i);
}


size_t ANTLRv4Parser::ThrowsSpecContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleThrowsSpec;
}

void ANTLRv4Parser::ThrowsSpecContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterThrowsSpec(this);
}

void ANTLRv4Parser::ThrowsSpecContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitThrowsSpec(this);
}


antlrcpp::Any ANTLRv4Parser::ThrowsSpecContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitThrowsSpec(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ThrowsSpecContext* ANTLRv4Parser::throwsSpec() {
  ThrowsSpecContext *_localctx = _tracker.createInstance<ThrowsSpecContext>(_ctx, getState());
  enterRule(_localctx, 60, ANTLRv4Parser::RuleThrowsSpec);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(496);
    match(ANTLRv4Parser::THROWS);
    setState(497);
    qid();
    setState(502);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == ANTLRv4Parser::COMMA) {
      setState(498);
      match(ANTLRv4Parser::COMMA);
      setState(499);
      qid();
      setState(504);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LocalsSpecContext ------------------------------------------------------------------

ANTLRv4Parser::LocalsSpecContext::LocalsSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::LocalsSpecContext::LOCALS() {
  return getToken(ANTLRv4Parser::LOCALS, 0);
}

ANTLRv4Parser::ArgActionParametersContext* ANTLRv4Parser::LocalsSpecContext::argActionParameters() {
  return getRuleContext<ANTLRv4Parser::ArgActionParametersContext>(0);
}


size_t ANTLRv4Parser::LocalsSpecContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLocalsSpec;
}

void ANTLRv4Parser::LocalsSpecContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLocalsSpec(this);
}

void ANTLRv4Parser::LocalsSpecContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLocalsSpec(this);
}


antlrcpp::Any ANTLRv4Parser::LocalsSpecContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLocalsSpec(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LocalsSpecContext* ANTLRv4Parser::localsSpec() {
  LocalsSpecContext *_localctx = _tracker.createInstance<LocalsSpecContext>(_ctx, getState());
  enterRule(_localctx, 62, ANTLRv4Parser::RuleLocalsSpec);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(505);
    match(ANTLRv4Parser::LOCALS);
    setState(506);
    argActionParameters();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RuleActionContext ------------------------------------------------------------------

ANTLRv4Parser::RuleActionContext::RuleActionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::RuleActionContext::AT() {
  return getToken(ANTLRv4Parser::AT, 0);
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::RuleActionContext::id() {
  return getRuleContext<ANTLRv4Parser::IdContext>(0);
}

ANTLRv4Parser::ActionBlockContext* ANTLRv4Parser::RuleActionContext::actionBlock() {
  return getRuleContext<ANTLRv4Parser::ActionBlockContext>(0);
}


size_t ANTLRv4Parser::RuleActionContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleRuleAction;
}

void ANTLRv4Parser::RuleActionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRuleAction(this);
}

void ANTLRv4Parser::RuleActionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRuleAction(this);
}


antlrcpp::Any ANTLRv4Parser::RuleActionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitRuleAction(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::RuleActionContext* ANTLRv4Parser::ruleAction() {
  RuleActionContext *_localctx = _tracker.createInstance<RuleActionContext>(_ctx, getState());
  enterRule(_localctx, 64, ANTLRv4Parser::RuleRuleAction);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(508);
    match(ANTLRv4Parser::AT);
    setState(509);
    id();
    setState(510);
    actionBlock();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RuleModifiersContext ------------------------------------------------------------------

ANTLRv4Parser::RuleModifiersContext::RuleModifiersContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<ANTLRv4Parser::RuleModifierContext *> ANTLRv4Parser::RuleModifiersContext::ruleModifier() {
  return getRuleContexts<ANTLRv4Parser::RuleModifierContext>();
}

ANTLRv4Parser::RuleModifierContext* ANTLRv4Parser::RuleModifiersContext::ruleModifier(size_t i) {
  return getRuleContext<ANTLRv4Parser::RuleModifierContext>(i);
}


size_t ANTLRv4Parser::RuleModifiersContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleRuleModifiers;
}

void ANTLRv4Parser::RuleModifiersContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRuleModifiers(this);
}

void ANTLRv4Parser::RuleModifiersContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRuleModifiers(this);
}


antlrcpp::Any ANTLRv4Parser::RuleModifiersContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitRuleModifiers(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::RuleModifiersContext* ANTLRv4Parser::ruleModifiers() {
  RuleModifiersContext *_localctx = _tracker.createInstance<RuleModifiersContext>(_ctx, getState());
  enterRule(_localctx, 66, ANTLRv4Parser::RuleRuleModifiers);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(513); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(512);
      ruleModifier();
      setState(515); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << ANTLRv4Parser::FRAGMENT)
      | (1ULL << ANTLRv4Parser::PROTECTED)
      | (1ULL << ANTLRv4Parser::PUBLIC)
      | (1ULL << ANTLRv4Parser::PRIVATE))) != 0));
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RuleModifierContext ------------------------------------------------------------------

ANTLRv4Parser::RuleModifierContext::RuleModifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::RuleModifierContext::PUBLIC() {
  return getToken(ANTLRv4Parser::PUBLIC, 0);
}

tree::TerminalNode* ANTLRv4Parser::RuleModifierContext::PRIVATE() {
  return getToken(ANTLRv4Parser::PRIVATE, 0);
}

tree::TerminalNode* ANTLRv4Parser::RuleModifierContext::PROTECTED() {
  return getToken(ANTLRv4Parser::PROTECTED, 0);
}

tree::TerminalNode* ANTLRv4Parser::RuleModifierContext::FRAGMENT() {
  return getToken(ANTLRv4Parser::FRAGMENT, 0);
}


size_t ANTLRv4Parser::RuleModifierContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleRuleModifier;
}

void ANTLRv4Parser::RuleModifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRuleModifier(this);
}

void ANTLRv4Parser::RuleModifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRuleModifier(this);
}


antlrcpp::Any ANTLRv4Parser::RuleModifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitRuleModifier(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::RuleModifierContext* ANTLRv4Parser::ruleModifier() {
  RuleModifierContext *_localctx = _tracker.createInstance<RuleModifierContext>(_ctx, getState());
  enterRule(_localctx, 68, ANTLRv4Parser::RuleRuleModifier);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(517);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << ANTLRv4Parser::FRAGMENT)
      | (1ULL << ANTLRv4Parser::PROTECTED)
      | (1ULL << ANTLRv4Parser::PUBLIC)
      | (1ULL << ANTLRv4Parser::PRIVATE))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RuleBlockContext ------------------------------------------------------------------

ANTLRv4Parser::RuleBlockContext::RuleBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::RuleAltListContext* ANTLRv4Parser::RuleBlockContext::ruleAltList() {
  return getRuleContext<ANTLRv4Parser::RuleAltListContext>(0);
}


size_t ANTLRv4Parser::RuleBlockContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleRuleBlock;
}

void ANTLRv4Parser::RuleBlockContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRuleBlock(this);
}

void ANTLRv4Parser::RuleBlockContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRuleBlock(this);
}


antlrcpp::Any ANTLRv4Parser::RuleBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitRuleBlock(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::RuleBlockContext* ANTLRv4Parser::ruleBlock() {
  RuleBlockContext *_localctx = _tracker.createInstance<RuleBlockContext>(_ctx, getState());
  enterRule(_localctx, 70, ANTLRv4Parser::RuleRuleBlock);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(519);
    ruleAltList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RuleAltListContext ------------------------------------------------------------------

ANTLRv4Parser::RuleAltListContext::RuleAltListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<ANTLRv4Parser::LabeledAltContext *> ANTLRv4Parser::RuleAltListContext::labeledAlt() {
  return getRuleContexts<ANTLRv4Parser::LabeledAltContext>();
}

ANTLRv4Parser::LabeledAltContext* ANTLRv4Parser::RuleAltListContext::labeledAlt(size_t i) {
  return getRuleContext<ANTLRv4Parser::LabeledAltContext>(i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::RuleAltListContext::OR() {
  return getTokens(ANTLRv4Parser::OR);
}

tree::TerminalNode* ANTLRv4Parser::RuleAltListContext::OR(size_t i) {
  return getToken(ANTLRv4Parser::OR, i);
}


size_t ANTLRv4Parser::RuleAltListContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleRuleAltList;
}

void ANTLRv4Parser::RuleAltListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRuleAltList(this);
}

void ANTLRv4Parser::RuleAltListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRuleAltList(this);
}


antlrcpp::Any ANTLRv4Parser::RuleAltListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitRuleAltList(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::RuleAltListContext* ANTLRv4Parser::ruleAltList() {
  RuleAltListContext *_localctx = _tracker.createInstance<RuleAltListContext>(_ctx, getState());
  enterRule(_localctx, 72, ANTLRv4Parser::RuleRuleAltList);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(521);
    labeledAlt();
    setState(526);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == ANTLRv4Parser::OR) {
      setState(522);
      match(ANTLRv4Parser::OR);
      setState(523);
      labeledAlt();
      setState(528);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LabeledAltContext ------------------------------------------------------------------

ANTLRv4Parser::LabeledAltContext::LabeledAltContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::AlternativeContext* ANTLRv4Parser::LabeledAltContext::alternative() {
  return getRuleContext<ANTLRv4Parser::AlternativeContext>(0);
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::LabeledAltContext::id() {
  return getRuleContext<ANTLRv4Parser::IdContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::LabeledAltContext::POUND() {
  return getToken(ANTLRv4Parser::POUND, 0);
}


size_t ANTLRv4Parser::LabeledAltContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLabeledAlt;
}

void ANTLRv4Parser::LabeledAltContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLabeledAlt(this);
}

void ANTLRv4Parser::LabeledAltContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLabeledAlt(this);
}


antlrcpp::Any ANTLRv4Parser::LabeledAltContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLabeledAlt(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LabeledAltContext* ANTLRv4Parser::labeledAlt() {
  LabeledAltContext *_localctx = _tracker.createInstance<LabeledAltContext>(_ctx, getState());
  enterRule(_localctx, 74, ANTLRv4Parser::RuleLabeledAlt);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(529);
    alternative();
    setState(532);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == ANTLRv4Parser::POUND) {
      setState(530);
      dynamic_cast<LabeledAltContext *>(_localctx)->poundExisted = match(ANTLRv4Parser::POUND);
      setState(531);
      id();
    }

    		dynamic_cast<LabeledAltContext *>(_localctx)->hasPOUND =  nullptr != dynamic_cast<LabeledAltContext *>(_localctx)->poundExisted;
    	
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LexerRuleContext ------------------------------------------------------------------

ANTLRv4Parser::LexerRuleContext::LexerRuleContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::LexerRuleContext::COLON() {
  return getToken(ANTLRv4Parser::COLON, 0);
}

ANTLRv4Parser::LexerRuleBlockContext* ANTLRv4Parser::LexerRuleContext::lexerRuleBlock() {
  return getRuleContext<ANTLRv4Parser::LexerRuleBlockContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::LexerRuleContext::SEMI() {
  return getToken(ANTLRv4Parser::SEMI, 0);
}

tree::TerminalNode* ANTLRv4Parser::LexerRuleContext::TOKEN_REF() {
  return getToken(ANTLRv4Parser::TOKEN_REF, 0);
}

tree::TerminalNode* ANTLRv4Parser::LexerRuleContext::DOC_COMMENT() {
  return getToken(ANTLRv4Parser::DOC_COMMENT, 0);
}

tree::TerminalNode* ANTLRv4Parser::LexerRuleContext::FRAGMENT() {
  return getToken(ANTLRv4Parser::FRAGMENT, 0);
}


size_t ANTLRv4Parser::LexerRuleContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLexerRule;
}

void ANTLRv4Parser::LexerRuleContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLexerRule(this);
}

void ANTLRv4Parser::LexerRuleContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLexerRule(this);
}


antlrcpp::Any ANTLRv4Parser::LexerRuleContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLexerRule(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LexerRuleContext* ANTLRv4Parser::lexerRule() {
  LexerRuleContext *_localctx = _tracker.createInstance<LexerRuleContext>(_ctx, getState());
  enterRule(_localctx, 76, ANTLRv4Parser::RuleLexerRule);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(537);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == ANTLRv4Parser::DOC_COMMENT) {
      setState(536);
      match(ANTLRv4Parser::DOC_COMMENT);
    }
    setState(540);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == ANTLRv4Parser::FRAGMENT) {
      setState(539);
      match(ANTLRv4Parser::FRAGMENT);
    }
    setState(542);
    dynamic_cast<LexerRuleContext *>(_localctx)->name = match(ANTLRv4Parser::TOKEN_REF);
    setState(543);
    match(ANTLRv4Parser::COLON);
    setState(544);
    lexerRuleBlock();
    setState(545);
    match(ANTLRv4Parser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LexerRuleBlockContext ------------------------------------------------------------------

ANTLRv4Parser::LexerRuleBlockContext::LexerRuleBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::LexerAltListContext* ANTLRv4Parser::LexerRuleBlockContext::lexerAltList() {
  return getRuleContext<ANTLRv4Parser::LexerAltListContext>(0);
}


size_t ANTLRv4Parser::LexerRuleBlockContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLexerRuleBlock;
}

void ANTLRv4Parser::LexerRuleBlockContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLexerRuleBlock(this);
}

void ANTLRv4Parser::LexerRuleBlockContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLexerRuleBlock(this);
}


antlrcpp::Any ANTLRv4Parser::LexerRuleBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLexerRuleBlock(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LexerRuleBlockContext* ANTLRv4Parser::lexerRuleBlock() {
  LexerRuleBlockContext *_localctx = _tracker.createInstance<LexerRuleBlockContext>(_ctx, getState());
  enterRule(_localctx, 78, ANTLRv4Parser::RuleLexerRuleBlock);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(547);
    lexerAltList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LexerAltListContext ------------------------------------------------------------------

ANTLRv4Parser::LexerAltListContext::LexerAltListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<ANTLRv4Parser::LexerAltContext *> ANTLRv4Parser::LexerAltListContext::lexerAlt() {
  return getRuleContexts<ANTLRv4Parser::LexerAltContext>();
}

ANTLRv4Parser::LexerAltContext* ANTLRv4Parser::LexerAltListContext::lexerAlt(size_t i) {
  return getRuleContext<ANTLRv4Parser::LexerAltContext>(i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::LexerAltListContext::OR() {
  return getTokens(ANTLRv4Parser::OR);
}

tree::TerminalNode* ANTLRv4Parser::LexerAltListContext::OR(size_t i) {
  return getToken(ANTLRv4Parser::OR, i);
}


size_t ANTLRv4Parser::LexerAltListContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLexerAltList;
}

void ANTLRv4Parser::LexerAltListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLexerAltList(this);
}

void ANTLRv4Parser::LexerAltListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLexerAltList(this);
}


antlrcpp::Any ANTLRv4Parser::LexerAltListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLexerAltList(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LexerAltListContext* ANTLRv4Parser::lexerAltList() {
  LexerAltListContext *_localctx = _tracker.createInstance<LexerAltListContext>(_ctx, getState());
  enterRule(_localctx, 80, ANTLRv4Parser::RuleLexerAltList);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(549);
    lexerAlt();
    setState(554);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == ANTLRv4Parser::OR) {
      setState(550);
      match(ANTLRv4Parser::OR);
      setState(551);
      lexerAlt();
      setState(556);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LexerAltContext ------------------------------------------------------------------

ANTLRv4Parser::LexerAltContext::LexerAltContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::LexerElementsContext* ANTLRv4Parser::LexerAltContext::lexerElements() {
  return getRuleContext<ANTLRv4Parser::LexerElementsContext>(0);
}

ANTLRv4Parser::LexerCommandsContext* ANTLRv4Parser::LexerAltContext::lexerCommands() {
  return getRuleContext<ANTLRv4Parser::LexerCommandsContext>(0);
}


size_t ANTLRv4Parser::LexerAltContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLexerAlt;
}

void ANTLRv4Parser::LexerAltContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLexerAlt(this);
}

void ANTLRv4Parser::LexerAltContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLexerAlt(this);
}


antlrcpp::Any ANTLRv4Parser::LexerAltContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLexerAlt(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LexerAltContext* ANTLRv4Parser::lexerAlt() {
  LexerAltContext *_localctx = _tracker.createInstance<LexerAltContext>(_ctx, getState());
  enterRule(_localctx, 82, ANTLRv4Parser::RuleLexerAlt);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(558);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << ANTLRv4Parser::TOKEN_REF)
      | (1ULL << ANTLRv4Parser::RULE_REF)
      | (1ULL << ANTLRv4Parser::LEXER_CHAR_SET)
      | (1ULL << ANTLRv4Parser::BEGIN_ACTION)
      | (1ULL << ANTLRv4Parser::LPAREN)
      | (1ULL << ANTLRv4Parser::DOT)
      | (1ULL << ANTLRv4Parser::NOT)
      | (1ULL << ANTLRv4Parser::STRING_LITERAL))) != 0)) {
      setState(557);
      lexerElements();
    }
    setState(561);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == ANTLRv4Parser::RARROW) {
      setState(560);
      lexerCommands();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LexerElementsContext ------------------------------------------------------------------

ANTLRv4Parser::LexerElementsContext::LexerElementsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<ANTLRv4Parser::LexerElementContext *> ANTLRv4Parser::LexerElementsContext::lexerElement() {
  return getRuleContexts<ANTLRv4Parser::LexerElementContext>();
}

ANTLRv4Parser::LexerElementContext* ANTLRv4Parser::LexerElementsContext::lexerElement(size_t i) {
  return getRuleContext<ANTLRv4Parser::LexerElementContext>(i);
}


size_t ANTLRv4Parser::LexerElementsContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLexerElements;
}

void ANTLRv4Parser::LexerElementsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLexerElements(this);
}

void ANTLRv4Parser::LexerElementsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLexerElements(this);
}


antlrcpp::Any ANTLRv4Parser::LexerElementsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLexerElements(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LexerElementsContext* ANTLRv4Parser::lexerElements() {
  LexerElementsContext *_localctx = _tracker.createInstance<LexerElementsContext>(_ctx, getState());
  enterRule(_localctx, 84, ANTLRv4Parser::RuleLexerElements);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(564); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(563);
      lexerElement();
      setState(566); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << ANTLRv4Parser::TOKEN_REF)
      | (1ULL << ANTLRv4Parser::RULE_REF)
      | (1ULL << ANTLRv4Parser::LEXER_CHAR_SET)
      | (1ULL << ANTLRv4Parser::BEGIN_ACTION)
      | (1ULL << ANTLRv4Parser::LPAREN)
      | (1ULL << ANTLRv4Parser::DOT)
      | (1ULL << ANTLRv4Parser::NOT)
      | (1ULL << ANTLRv4Parser::STRING_LITERAL))) != 0));
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LexerElementContext ------------------------------------------------------------------

ANTLRv4Parser::LexerElementContext::LexerElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::LabeledLexerElementContext* ANTLRv4Parser::LexerElementContext::labeledLexerElement() {
  return getRuleContext<ANTLRv4Parser::LabeledLexerElementContext>(0);
}

ANTLRv4Parser::EbnfSuffixContext* ANTLRv4Parser::LexerElementContext::ebnfSuffix() {
  return getRuleContext<ANTLRv4Parser::EbnfSuffixContext>(0);
}

ANTLRv4Parser::LexerAtomContext* ANTLRv4Parser::LexerElementContext::lexerAtom() {
  return getRuleContext<ANTLRv4Parser::LexerAtomContext>(0);
}

ANTLRv4Parser::LexerBlockContext* ANTLRv4Parser::LexerElementContext::lexerBlock() {
  return getRuleContext<ANTLRv4Parser::LexerBlockContext>(0);
}

ANTLRv4Parser::ActionBlockContext* ANTLRv4Parser::LexerElementContext::actionBlock() {
  return getRuleContext<ANTLRv4Parser::ActionBlockContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::LexerElementContext::QUESTION() {
  return getToken(ANTLRv4Parser::QUESTION, 0);
}


size_t ANTLRv4Parser::LexerElementContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLexerElement;
}

void ANTLRv4Parser::LexerElementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLexerElement(this);
}

void ANTLRv4Parser::LexerElementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLexerElement(this);
}


antlrcpp::Any ANTLRv4Parser::LexerElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLexerElement(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LexerElementContext* ANTLRv4Parser::lexerElement() {
  LexerElementContext *_localctx = _tracker.createInstance<LexerElementContext>(_ctx, getState());
  enterRule(_localctx, 86, ANTLRv4Parser::RuleLexerElement);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(584);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 66, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(568);
      labeledLexerElement();
      setState(570);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << ANTLRv4Parser::QUESTION)
        | (1ULL << ANTLRv4Parser::STAR)
        | (1ULL << ANTLRv4Parser::PLUS))) != 0)) {
        setState(569);
        ebnfSuffix();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(572);
      lexerAtom();
      setState(574);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << ANTLRv4Parser::QUESTION)
        | (1ULL << ANTLRv4Parser::STAR)
        | (1ULL << ANTLRv4Parser::PLUS))) != 0)) {
        setState(573);
        ebnfSuffix();
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(576);
      lexerBlock();
      setState(578);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << ANTLRv4Parser::QUESTION)
        | (1ULL << ANTLRv4Parser::STAR)
        | (1ULL << ANTLRv4Parser::PLUS))) != 0)) {
        setState(577);
        ebnfSuffix();
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(580);
      actionBlock();
      setState(582);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == ANTLRv4Parser::QUESTION) {
        setState(581);
        match(ANTLRv4Parser::QUESTION);
      }
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LabeledLexerElementContext ------------------------------------------------------------------

ANTLRv4Parser::LabeledLexerElementContext::LabeledLexerElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::LabeledLexerElementContext::id() {
  return getRuleContext<ANTLRv4Parser::IdContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::LabeledLexerElementContext::ASSIGN() {
  return getToken(ANTLRv4Parser::ASSIGN, 0);
}

tree::TerminalNode* ANTLRv4Parser::LabeledLexerElementContext::PLUS_ASSIGN() {
  return getToken(ANTLRv4Parser::PLUS_ASSIGN, 0);
}

ANTLRv4Parser::LexerAtomContext* ANTLRv4Parser::LabeledLexerElementContext::lexerAtom() {
  return getRuleContext<ANTLRv4Parser::LexerAtomContext>(0);
}

ANTLRv4Parser::BlockContext* ANTLRv4Parser::LabeledLexerElementContext::block() {
  return getRuleContext<ANTLRv4Parser::BlockContext>(0);
}


size_t ANTLRv4Parser::LabeledLexerElementContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLabeledLexerElement;
}

void ANTLRv4Parser::LabeledLexerElementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLabeledLexerElement(this);
}

void ANTLRv4Parser::LabeledLexerElementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLabeledLexerElement(this);
}


antlrcpp::Any ANTLRv4Parser::LabeledLexerElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLabeledLexerElement(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LabeledLexerElementContext* ANTLRv4Parser::labeledLexerElement() {
  LabeledLexerElementContext *_localctx = _tracker.createInstance<LabeledLexerElementContext>(_ctx, getState());
  enterRule(_localctx, 88, ANTLRv4Parser::RuleLabeledLexerElement);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(586);
    id();
    setState(587);
    dynamic_cast<LabeledLexerElementContext *>(_localctx)->ass = _input->LT(1);
    _la = _input->LA(1);
    if (!(_la == ANTLRv4Parser::ASSIGN

    || _la == ANTLRv4Parser::PLUS_ASSIGN)) {
      dynamic_cast<LabeledLexerElementContext *>(_localctx)->ass = _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(590);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case ANTLRv4Parser::TOKEN_REF:
      case ANTLRv4Parser::RULE_REF:
      case ANTLRv4Parser::LEXER_CHAR_SET:
      case ANTLRv4Parser::DOT:
      case ANTLRv4Parser::NOT:
      case ANTLRv4Parser::STRING_LITERAL: {
        setState(588);
        lexerAtom();
        break;
      }

      case ANTLRv4Parser::LPAREN: {
        setState(589);
        block();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LexerBlockContext ------------------------------------------------------------------

ANTLRv4Parser::LexerBlockContext::LexerBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::LexerBlockContext::LPAREN() {
  return getToken(ANTLRv4Parser::LPAREN, 0);
}

ANTLRv4Parser::LexerAltListContext* ANTLRv4Parser::LexerBlockContext::lexerAltList() {
  return getRuleContext<ANTLRv4Parser::LexerAltListContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::LexerBlockContext::RPAREN() {
  return getToken(ANTLRv4Parser::RPAREN, 0);
}


size_t ANTLRv4Parser::LexerBlockContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLexerBlock;
}

void ANTLRv4Parser::LexerBlockContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLexerBlock(this);
}

void ANTLRv4Parser::LexerBlockContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLexerBlock(this);
}


antlrcpp::Any ANTLRv4Parser::LexerBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLexerBlock(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LexerBlockContext* ANTLRv4Parser::lexerBlock() {
  LexerBlockContext *_localctx = _tracker.createInstance<LexerBlockContext>(_ctx, getState());
  enterRule(_localctx, 90, ANTLRv4Parser::RuleLexerBlock);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(592);
    match(ANTLRv4Parser::LPAREN);
    setState(593);
    lexerAltList();
    setState(594);
    match(ANTLRv4Parser::RPAREN);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LexerCommandsContext ------------------------------------------------------------------

ANTLRv4Parser::LexerCommandsContext::LexerCommandsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::LexerCommandsContext::RARROW() {
  return getToken(ANTLRv4Parser::RARROW, 0);
}

std::vector<ANTLRv4Parser::LexerCommandContext *> ANTLRv4Parser::LexerCommandsContext::lexerCommand() {
  return getRuleContexts<ANTLRv4Parser::LexerCommandContext>();
}

ANTLRv4Parser::LexerCommandContext* ANTLRv4Parser::LexerCommandsContext::lexerCommand(size_t i) {
  return getRuleContext<ANTLRv4Parser::LexerCommandContext>(i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::LexerCommandsContext::COMMA() {
  return getTokens(ANTLRv4Parser::COMMA);
}

tree::TerminalNode* ANTLRv4Parser::LexerCommandsContext::COMMA(size_t i) {
  return getToken(ANTLRv4Parser::COMMA, i);
}


size_t ANTLRv4Parser::LexerCommandsContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLexerCommands;
}

void ANTLRv4Parser::LexerCommandsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLexerCommands(this);
}

void ANTLRv4Parser::LexerCommandsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLexerCommands(this);
}


antlrcpp::Any ANTLRv4Parser::LexerCommandsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLexerCommands(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LexerCommandsContext* ANTLRv4Parser::lexerCommands() {
  LexerCommandsContext *_localctx = _tracker.createInstance<LexerCommandsContext>(_ctx, getState());
  enterRule(_localctx, 92, ANTLRv4Parser::RuleLexerCommands);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(596);
    match(ANTLRv4Parser::RARROW);
    setState(597);
    lexerCommand();
    setState(602);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == ANTLRv4Parser::COMMA) {
      setState(598);
      match(ANTLRv4Parser::COMMA);
      setState(599);
      lexerCommand();
      setState(604);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LexerCommandContext ------------------------------------------------------------------

ANTLRv4Parser::LexerCommandContext::LexerCommandContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::LexerCommandNameContext* ANTLRv4Parser::LexerCommandContext::lexerCommandName() {
  return getRuleContext<ANTLRv4Parser::LexerCommandNameContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::LexerCommandContext::LPAREN() {
  return getToken(ANTLRv4Parser::LPAREN, 0);
}

ANTLRv4Parser::LexerCommandExprContext* ANTLRv4Parser::LexerCommandContext::lexerCommandExpr() {
  return getRuleContext<ANTLRv4Parser::LexerCommandExprContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::LexerCommandContext::RPAREN() {
  return getToken(ANTLRv4Parser::RPAREN, 0);
}


size_t ANTLRv4Parser::LexerCommandContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLexerCommand;
}

void ANTLRv4Parser::LexerCommandContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLexerCommand(this);
}

void ANTLRv4Parser::LexerCommandContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLexerCommand(this);
}


antlrcpp::Any ANTLRv4Parser::LexerCommandContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLexerCommand(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LexerCommandContext* ANTLRv4Parser::lexerCommand() {
  LexerCommandContext *_localctx = _tracker.createInstance<LexerCommandContext>(_ctx, getState());
  enterRule(_localctx, 94, ANTLRv4Parser::RuleLexerCommand);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(611);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 69, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(605);
      lexerCommandName();
      setState(606);
      match(ANTLRv4Parser::LPAREN);
      setState(607);
      lexerCommandExpr();
      setState(608);
      match(ANTLRv4Parser::RPAREN);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(610);
      lexerCommandName();
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LexerCommandNameContext ------------------------------------------------------------------

ANTLRv4Parser::LexerCommandNameContext::LexerCommandNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::LexerCommandNameContext::id() {
  return getRuleContext<ANTLRv4Parser::IdContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::LexerCommandNameContext::MODE() {
  return getToken(ANTLRv4Parser::MODE, 0);
}


size_t ANTLRv4Parser::LexerCommandNameContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLexerCommandName;
}

void ANTLRv4Parser::LexerCommandNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLexerCommandName(this);
}

void ANTLRv4Parser::LexerCommandNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLexerCommandName(this);
}


antlrcpp::Any ANTLRv4Parser::LexerCommandNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLexerCommandName(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LexerCommandNameContext* ANTLRv4Parser::lexerCommandName() {
  LexerCommandNameContext *_localctx = _tracker.createInstance<LexerCommandNameContext>(_ctx, getState());
  enterRule(_localctx, 96, ANTLRv4Parser::RuleLexerCommandName);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(615);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case ANTLRv4Parser::TOKEN_REF:
      case ANTLRv4Parser::RULE_REF: {
        enterOuterAlt(_localctx, 1);
        setState(613);
        id();
        break;
      }

      case ANTLRv4Parser::MODE: {
        enterOuterAlt(_localctx, 2);
        setState(614);
        match(ANTLRv4Parser::MODE);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LexerCommandExprContext ------------------------------------------------------------------

ANTLRv4Parser::LexerCommandExprContext::LexerCommandExprContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::LexerCommandExprContext::id() {
  return getRuleContext<ANTLRv4Parser::IdContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::LexerCommandExprContext::INT() {
  return getToken(ANTLRv4Parser::INT, 0);
}


size_t ANTLRv4Parser::LexerCommandExprContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLexerCommandExpr;
}

void ANTLRv4Parser::LexerCommandExprContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLexerCommandExpr(this);
}

void ANTLRv4Parser::LexerCommandExprContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLexerCommandExpr(this);
}


antlrcpp::Any ANTLRv4Parser::LexerCommandExprContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLexerCommandExpr(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LexerCommandExprContext* ANTLRv4Parser::lexerCommandExpr() {
  LexerCommandExprContext *_localctx = _tracker.createInstance<LexerCommandExprContext>(_ctx, getState());
  enterRule(_localctx, 98, ANTLRv4Parser::RuleLexerCommandExpr);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(619);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case ANTLRv4Parser::TOKEN_REF:
      case ANTLRv4Parser::RULE_REF: {
        enterOuterAlt(_localctx, 1);
        setState(617);
        id();
        break;
      }

      case ANTLRv4Parser::INT: {
        enterOuterAlt(_localctx, 2);
        setState(618);
        match(ANTLRv4Parser::INT);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AltListContext ------------------------------------------------------------------

ANTLRv4Parser::AltListContext::AltListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<ANTLRv4Parser::AlternativeContext *> ANTLRv4Parser::AltListContext::alternative() {
  return getRuleContexts<ANTLRv4Parser::AlternativeContext>();
}

ANTLRv4Parser::AlternativeContext* ANTLRv4Parser::AltListContext::alternative(size_t i) {
  return getRuleContext<ANTLRv4Parser::AlternativeContext>(i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::AltListContext::OR() {
  return getTokens(ANTLRv4Parser::OR);
}

tree::TerminalNode* ANTLRv4Parser::AltListContext::OR(size_t i) {
  return getToken(ANTLRv4Parser::OR, i);
}


size_t ANTLRv4Parser::AltListContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleAltList;
}

void ANTLRv4Parser::AltListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAltList(this);
}

void ANTLRv4Parser::AltListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAltList(this);
}


antlrcpp::Any ANTLRv4Parser::AltListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitAltList(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::AltListContext* ANTLRv4Parser::altList() {
  AltListContext *_localctx = _tracker.createInstance<AltListContext>(_ctx, getState());
  enterRule(_localctx, 100, ANTLRv4Parser::RuleAltList);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(621);
    alternative();
    setState(626);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == ANTLRv4Parser::OR) {
      setState(622);
      match(ANTLRv4Parser::OR);
      setState(623);
      alternative();
      setState(628);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlternativeContext ------------------------------------------------------------------

ANTLRv4Parser::AlternativeContext::AlternativeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::ElementsContext* ANTLRv4Parser::AlternativeContext::elements() {
  return getRuleContext<ANTLRv4Parser::ElementsContext>(0);
}


size_t ANTLRv4Parser::AlternativeContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleAlternative;
}

void ANTLRv4Parser::AlternativeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlternative(this);
}

void ANTLRv4Parser::AlternativeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlternative(this);
}


antlrcpp::Any ANTLRv4Parser::AlternativeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitAlternative(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::AlternativeContext* ANTLRv4Parser::alternative() {
  AlternativeContext *_localctx = _tracker.createInstance<AlternativeContext>(_ctx, getState());
  enterRule(_localctx, 102, ANTLRv4Parser::RuleAlternative);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(631);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case ANTLRv4Parser::TOKEN_REF:
      case ANTLRv4Parser::RULE_REF:
      case ANTLRv4Parser::BEGIN_ACTION:
      case ANTLRv4Parser::LPAREN:
      case ANTLRv4Parser::DOT:
      case ANTLRv4Parser::NOT:
      case ANTLRv4Parser::STRING_LITERAL: {
        enterOuterAlt(_localctx, 1);
        setState(629);
        elements();
        break;
      }

      case ANTLRv4Parser::SEMI:
      case ANTLRv4Parser::RPAREN:
      case ANTLRv4Parser::OR:
      case ANTLRv4Parser::POUND: {
        enterOuterAlt(_localctx, 2);

        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ElementsContext ------------------------------------------------------------------

ANTLRv4Parser::ElementsContext::ElementsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<ANTLRv4Parser::ElementContext *> ANTLRv4Parser::ElementsContext::element() {
  return getRuleContexts<ANTLRv4Parser::ElementContext>();
}

ANTLRv4Parser::ElementContext* ANTLRv4Parser::ElementsContext::element(size_t i) {
  return getRuleContext<ANTLRv4Parser::ElementContext>(i);
}


size_t ANTLRv4Parser::ElementsContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleElements;
}

void ANTLRv4Parser::ElementsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterElements(this);
}

void ANTLRv4Parser::ElementsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitElements(this);
}


antlrcpp::Any ANTLRv4Parser::ElementsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitElements(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ElementsContext* ANTLRv4Parser::elements() {
  ElementsContext *_localctx = _tracker.createInstance<ElementsContext>(_ctx, getState());
  enterRule(_localctx, 104, ANTLRv4Parser::RuleElements);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(634); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(633);
      element();
      setState(636); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << ANTLRv4Parser::TOKEN_REF)
      | (1ULL << ANTLRv4Parser::RULE_REF)
      | (1ULL << ANTLRv4Parser::BEGIN_ACTION)
      | (1ULL << ANTLRv4Parser::LPAREN)
      | (1ULL << ANTLRv4Parser::DOT)
      | (1ULL << ANTLRv4Parser::NOT)
      | (1ULL << ANTLRv4Parser::STRING_LITERAL))) != 0));
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ElementContext ------------------------------------------------------------------

ANTLRv4Parser::ElementContext::ElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::LabeledElementContext* ANTLRv4Parser::ElementContext::labeledElement() {
  return getRuleContext<ANTLRv4Parser::LabeledElementContext>(0);
}

ANTLRv4Parser::EbnfSuffixContext* ANTLRv4Parser::ElementContext::ebnfSuffix() {
  return getRuleContext<ANTLRv4Parser::EbnfSuffixContext>(0);
}

ANTLRv4Parser::AtomContext* ANTLRv4Parser::ElementContext::atom() {
  return getRuleContext<ANTLRv4Parser::AtomContext>(0);
}

ANTLRv4Parser::EbnfContext* ANTLRv4Parser::ElementContext::ebnf() {
  return getRuleContext<ANTLRv4Parser::EbnfContext>(0);
}

ANTLRv4Parser::ActionBlockContext* ANTLRv4Parser::ElementContext::actionBlock() {
  return getRuleContext<ANTLRv4Parser::ActionBlockContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::ElementContext::QUESTION() {
  return getToken(ANTLRv4Parser::QUESTION, 0);
}


size_t ANTLRv4Parser::ElementContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleElement;
}

void ANTLRv4Parser::ElementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterElement(this);
}

void ANTLRv4Parser::ElementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitElement(this);
}


antlrcpp::Any ANTLRv4Parser::ElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitElement(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ElementContext* ANTLRv4Parser::element() {
  ElementContext *_localctx = _tracker.createInstance<ElementContext>(_ctx, getState());
  enterRule(_localctx, 106, ANTLRv4Parser::RuleElement);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(653);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 78, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(638);
      labeledElement();
      setState(641);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case ANTLRv4Parser::QUESTION:
        case ANTLRv4Parser::STAR:
        case ANTLRv4Parser::PLUS: {
          setState(639);
          ebnfSuffix();
          break;
        }

        case ANTLRv4Parser::TOKEN_REF:
        case ANTLRv4Parser::RULE_REF:
        case ANTLRv4Parser::BEGIN_ACTION:
        case ANTLRv4Parser::SEMI:
        case ANTLRv4Parser::LPAREN:
        case ANTLRv4Parser::RPAREN:
        case ANTLRv4Parser::OR:
        case ANTLRv4Parser::DOT:
        case ANTLRv4Parser::POUND:
        case ANTLRv4Parser::NOT:
        case ANTLRv4Parser::STRING_LITERAL: {
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(643);
      atom();
      setState(646);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case ANTLRv4Parser::QUESTION:
        case ANTLRv4Parser::STAR:
        case ANTLRv4Parser::PLUS: {
          setState(644);
          ebnfSuffix();
          break;
        }

        case ANTLRv4Parser::TOKEN_REF:
        case ANTLRv4Parser::RULE_REF:
        case ANTLRv4Parser::BEGIN_ACTION:
        case ANTLRv4Parser::SEMI:
        case ANTLRv4Parser::LPAREN:
        case ANTLRv4Parser::RPAREN:
        case ANTLRv4Parser::OR:
        case ANTLRv4Parser::DOT:
        case ANTLRv4Parser::POUND:
        case ANTLRv4Parser::NOT:
        case ANTLRv4Parser::STRING_LITERAL: {
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(648);
      ebnf();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(649);
      actionBlock();
      setState(651);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == ANTLRv4Parser::QUESTION) {
        setState(650);
        match(ANTLRv4Parser::QUESTION);
      }
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LabeledElementContext ------------------------------------------------------------------

ANTLRv4Parser::LabeledElementContext::LabeledElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::LabeledElementContext::id() {
  return getRuleContext<ANTLRv4Parser::IdContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::LabeledElementContext::ASSIGN() {
  return getToken(ANTLRv4Parser::ASSIGN, 0);
}

tree::TerminalNode* ANTLRv4Parser::LabeledElementContext::PLUS_ASSIGN() {
  return getToken(ANTLRv4Parser::PLUS_ASSIGN, 0);
}

ANTLRv4Parser::AtomContext* ANTLRv4Parser::LabeledElementContext::atom() {
  return getRuleContext<ANTLRv4Parser::AtomContext>(0);
}

ANTLRv4Parser::BlockContext* ANTLRv4Parser::LabeledElementContext::block() {
  return getRuleContext<ANTLRv4Parser::BlockContext>(0);
}


size_t ANTLRv4Parser::LabeledElementContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLabeledElement;
}

void ANTLRv4Parser::LabeledElementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLabeledElement(this);
}

void ANTLRv4Parser::LabeledElementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLabeledElement(this);
}


antlrcpp::Any ANTLRv4Parser::LabeledElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLabeledElement(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LabeledElementContext* ANTLRv4Parser::labeledElement() {
  LabeledElementContext *_localctx = _tracker.createInstance<LabeledElementContext>(_ctx, getState());
  enterRule(_localctx, 108, ANTLRv4Parser::RuleLabeledElement);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(655);
    dynamic_cast<LabeledElementContext *>(_localctx)->label = id();
    setState(656);
    dynamic_cast<LabeledElementContext *>(_localctx)->ass = _input->LT(1);
    _la = _input->LA(1);
    if (!(_la == ANTLRv4Parser::ASSIGN

    || _la == ANTLRv4Parser::PLUS_ASSIGN)) {
      dynamic_cast<LabeledElementContext *>(_localctx)->ass = _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(659);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case ANTLRv4Parser::TOKEN_REF:
      case ANTLRv4Parser::RULE_REF:
      case ANTLRv4Parser::DOT:
      case ANTLRv4Parser::NOT:
      case ANTLRv4Parser::STRING_LITERAL: {
        setState(657);
        atom();
        break;
      }

      case ANTLRv4Parser::LPAREN: {
        setState(658);
        block();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EbnfContext ------------------------------------------------------------------

ANTLRv4Parser::EbnfContext::EbnfContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::BlockContext* ANTLRv4Parser::EbnfContext::block() {
  return getRuleContext<ANTLRv4Parser::BlockContext>(0);
}

ANTLRv4Parser::BlockSuffixContext* ANTLRv4Parser::EbnfContext::blockSuffix() {
  return getRuleContext<ANTLRv4Parser::BlockSuffixContext>(0);
}


size_t ANTLRv4Parser::EbnfContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleEbnf;
}

void ANTLRv4Parser::EbnfContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEbnf(this);
}

void ANTLRv4Parser::EbnfContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEbnf(this);
}


antlrcpp::Any ANTLRv4Parser::EbnfContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitEbnf(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::EbnfContext* ANTLRv4Parser::ebnf() {
  EbnfContext *_localctx = _tracker.createInstance<EbnfContext>(_ctx, getState());
  enterRule(_localctx, 110, ANTLRv4Parser::RuleEbnf);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(661);
    block();
    setState(664);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case ANTLRv4Parser::QUESTION:
      case ANTLRv4Parser::STAR:
      case ANTLRv4Parser::PLUS: {
        setState(662);
        blockSuffix();
        break;
      }

      case ANTLRv4Parser::TOKEN_REF:
      case ANTLRv4Parser::RULE_REF:
      case ANTLRv4Parser::BEGIN_ACTION:
      case ANTLRv4Parser::SEMI:
      case ANTLRv4Parser::LPAREN:
      case ANTLRv4Parser::RPAREN:
      case ANTLRv4Parser::OR:
      case ANTLRv4Parser::DOT:
      case ANTLRv4Parser::POUND:
      case ANTLRv4Parser::NOT:
      case ANTLRv4Parser::STRING_LITERAL: {
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BlockSuffixContext ------------------------------------------------------------------

ANTLRv4Parser::BlockSuffixContext::BlockSuffixContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::EbnfSuffixContext* ANTLRv4Parser::BlockSuffixContext::ebnfSuffix() {
  return getRuleContext<ANTLRv4Parser::EbnfSuffixContext>(0);
}


size_t ANTLRv4Parser::BlockSuffixContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleBlockSuffix;
}

void ANTLRv4Parser::BlockSuffixContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterBlockSuffix(this);
}

void ANTLRv4Parser::BlockSuffixContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitBlockSuffix(this);
}


antlrcpp::Any ANTLRv4Parser::BlockSuffixContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitBlockSuffix(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::BlockSuffixContext* ANTLRv4Parser::blockSuffix() {
  BlockSuffixContext *_localctx = _tracker.createInstance<BlockSuffixContext>(_ctx, getState());
  enterRule(_localctx, 112, ANTLRv4Parser::RuleBlockSuffix);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(666);
    ebnfSuffix();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EbnfSuffixContext ------------------------------------------------------------------

ANTLRv4Parser::EbnfSuffixContext::EbnfSuffixContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::EbnfSuffixContext::QUESTION() {
  return getToken(ANTLRv4Parser::QUESTION, 0);
}

tree::TerminalNode* ANTLRv4Parser::EbnfSuffixContext::STAR() {
  return getToken(ANTLRv4Parser::STAR, 0);
}

tree::TerminalNode* ANTLRv4Parser::EbnfSuffixContext::PLUS() {
  return getToken(ANTLRv4Parser::PLUS, 0);
}


size_t ANTLRv4Parser::EbnfSuffixContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleEbnfSuffix;
}

void ANTLRv4Parser::EbnfSuffixContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEbnfSuffix(this);
}

void ANTLRv4Parser::EbnfSuffixContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEbnfSuffix(this);
}


antlrcpp::Any ANTLRv4Parser::EbnfSuffixContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitEbnfSuffix(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::EbnfSuffixContext* ANTLRv4Parser::ebnfSuffix() {
  EbnfSuffixContext *_localctx = _tracker.createInstance<EbnfSuffixContext>(_ctx, getState());
  enterRule(_localctx, 114, ANTLRv4Parser::RuleEbnfSuffix);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(668);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << ANTLRv4Parser::QUESTION)
      | (1ULL << ANTLRv4Parser::STAR)
      | (1ULL << ANTLRv4Parser::PLUS))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LexerAtomContext ------------------------------------------------------------------

ANTLRv4Parser::LexerAtomContext::LexerAtomContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::RangeContext* ANTLRv4Parser::LexerAtomContext::range() {
  return getRuleContext<ANTLRv4Parser::RangeContext>(0);
}

ANTLRv4Parser::TerminalContext* ANTLRv4Parser::LexerAtomContext::terminal() {
  return getRuleContext<ANTLRv4Parser::TerminalContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::LexerAtomContext::RULE_REF() {
  return getToken(ANTLRv4Parser::RULE_REF, 0);
}

ANTLRv4Parser::NotSetContext* ANTLRv4Parser::LexerAtomContext::notSet() {
  return getRuleContext<ANTLRv4Parser::NotSetContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::LexerAtomContext::LEXER_CHAR_SET() {
  return getToken(ANTLRv4Parser::LEXER_CHAR_SET, 0);
}

tree::TerminalNode* ANTLRv4Parser::LexerAtomContext::DOT() {
  return getToken(ANTLRv4Parser::DOT, 0);
}

ANTLRv4Parser::ElementOptionsContext* ANTLRv4Parser::LexerAtomContext::elementOptions() {
  return getRuleContext<ANTLRv4Parser::ElementOptionsContext>(0);
}


size_t ANTLRv4Parser::LexerAtomContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleLexerAtom;
}

void ANTLRv4Parser::LexerAtomContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLexerAtom(this);
}

void ANTLRv4Parser::LexerAtomContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLexerAtom(this);
}


antlrcpp::Any ANTLRv4Parser::LexerAtomContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitLexerAtom(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::LexerAtomContext* ANTLRv4Parser::lexerAtom() {
  LexerAtomContext *_localctx = _tracker.createInstance<LexerAtomContext>(_ctx, getState());
  enterRule(_localctx, 116, ANTLRv4Parser::RuleLexerAtom);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(679);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 82, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(670);
      range();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(671);
      terminal();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(672);
      match(ANTLRv4Parser::RULE_REF);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(673);
      notSet();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(674);
      match(ANTLRv4Parser::LEXER_CHAR_SET);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(675);
      match(ANTLRv4Parser::DOT);
      setState(677);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == ANTLRv4Parser::LT) {
        setState(676);
        elementOptions();
      }
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AtomContext ------------------------------------------------------------------

ANTLRv4Parser::AtomContext::AtomContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::RangeContext* ANTLRv4Parser::AtomContext::range() {
  return getRuleContext<ANTLRv4Parser::RangeContext>(0);
}

ANTLRv4Parser::TerminalContext* ANTLRv4Parser::AtomContext::terminal() {
  return getRuleContext<ANTLRv4Parser::TerminalContext>(0);
}

ANTLRv4Parser::RulerefContext* ANTLRv4Parser::AtomContext::ruleref() {
  return getRuleContext<ANTLRv4Parser::RulerefContext>(0);
}

ANTLRv4Parser::NotSetContext* ANTLRv4Parser::AtomContext::notSet() {
  return getRuleContext<ANTLRv4Parser::NotSetContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::AtomContext::DOT() {
  return getToken(ANTLRv4Parser::DOT, 0);
}

ANTLRv4Parser::ElementOptionsContext* ANTLRv4Parser::AtomContext::elementOptions() {
  return getRuleContext<ANTLRv4Parser::ElementOptionsContext>(0);
}


size_t ANTLRv4Parser::AtomContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleAtom;
}

void ANTLRv4Parser::AtomContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAtom(this);
}

void ANTLRv4Parser::AtomContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAtom(this);
}


antlrcpp::Any ANTLRv4Parser::AtomContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitAtom(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::AtomContext* ANTLRv4Parser::atom() {
  AtomContext *_localctx = _tracker.createInstance<AtomContext>(_ctx, getState());
  enterRule(_localctx, 118, ANTLRv4Parser::RuleAtom);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(689);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 84, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(681);
      range();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(682);
      terminal();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(683);
      ruleref();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(684);
      notSet();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(685);
      match(ANTLRv4Parser::DOT);
      setState(687);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == ANTLRv4Parser::LT) {
        setState(686);
        elementOptions();
      }
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NotSetContext ------------------------------------------------------------------

ANTLRv4Parser::NotSetContext::NotSetContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::NotSetContext::NOT() {
  return getToken(ANTLRv4Parser::NOT, 0);
}

ANTLRv4Parser::SetElementContext* ANTLRv4Parser::NotSetContext::setElement() {
  return getRuleContext<ANTLRv4Parser::SetElementContext>(0);
}

ANTLRv4Parser::BlockSetContext* ANTLRv4Parser::NotSetContext::blockSet() {
  return getRuleContext<ANTLRv4Parser::BlockSetContext>(0);
}


size_t ANTLRv4Parser::NotSetContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleNotSet;
}

void ANTLRv4Parser::NotSetContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterNotSet(this);
}

void ANTLRv4Parser::NotSetContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitNotSet(this);
}


antlrcpp::Any ANTLRv4Parser::NotSetContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitNotSet(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::NotSetContext* ANTLRv4Parser::notSet() {
  NotSetContext *_localctx = _tracker.createInstance<NotSetContext>(_ctx, getState());
  enterRule(_localctx, 120, ANTLRv4Parser::RuleNotSet);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(695);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 85, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(691);
      match(ANTLRv4Parser::NOT);
      setState(692);
      setElement();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(693);
      match(ANTLRv4Parser::NOT);
      setState(694);
      blockSet();
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BlockSetContext ------------------------------------------------------------------

ANTLRv4Parser::BlockSetContext::BlockSetContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::BlockSetContext::LPAREN() {
  return getToken(ANTLRv4Parser::LPAREN, 0);
}

std::vector<ANTLRv4Parser::SetElementContext *> ANTLRv4Parser::BlockSetContext::setElement() {
  return getRuleContexts<ANTLRv4Parser::SetElementContext>();
}

ANTLRv4Parser::SetElementContext* ANTLRv4Parser::BlockSetContext::setElement(size_t i) {
  return getRuleContext<ANTLRv4Parser::SetElementContext>(i);
}

tree::TerminalNode* ANTLRv4Parser::BlockSetContext::RPAREN() {
  return getToken(ANTLRv4Parser::RPAREN, 0);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::BlockSetContext::OR() {
  return getTokens(ANTLRv4Parser::OR);
}

tree::TerminalNode* ANTLRv4Parser::BlockSetContext::OR(size_t i) {
  return getToken(ANTLRv4Parser::OR, i);
}


size_t ANTLRv4Parser::BlockSetContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleBlockSet;
}

void ANTLRv4Parser::BlockSetContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterBlockSet(this);
}

void ANTLRv4Parser::BlockSetContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitBlockSet(this);
}


antlrcpp::Any ANTLRv4Parser::BlockSetContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitBlockSet(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::BlockSetContext* ANTLRv4Parser::blockSet() {
  BlockSetContext *_localctx = _tracker.createInstance<BlockSetContext>(_ctx, getState());
  enterRule(_localctx, 122, ANTLRv4Parser::RuleBlockSet);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(697);
    match(ANTLRv4Parser::LPAREN);
    setState(698);
    setElement();
    setState(703);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == ANTLRv4Parser::OR) {
      setState(699);
      match(ANTLRv4Parser::OR);
      setState(700);
      setElement();
      setState(705);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(706);
    match(ANTLRv4Parser::RPAREN);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SetElementContext ------------------------------------------------------------------

ANTLRv4Parser::SetElementContext::SetElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::SetElementContext::TOKEN_REF() {
  return getToken(ANTLRv4Parser::TOKEN_REF, 0);
}

tree::TerminalNode* ANTLRv4Parser::SetElementContext::STRING_LITERAL() {
  return getToken(ANTLRv4Parser::STRING_LITERAL, 0);
}

ANTLRv4Parser::RangeContext* ANTLRv4Parser::SetElementContext::range() {
  return getRuleContext<ANTLRv4Parser::RangeContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::SetElementContext::LEXER_CHAR_SET() {
  return getToken(ANTLRv4Parser::LEXER_CHAR_SET, 0);
}


size_t ANTLRv4Parser::SetElementContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleSetElement;
}

void ANTLRv4Parser::SetElementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSetElement(this);
}

void ANTLRv4Parser::SetElementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSetElement(this);
}


antlrcpp::Any ANTLRv4Parser::SetElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitSetElement(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::SetElementContext* ANTLRv4Parser::setElement() {
  SetElementContext *_localctx = _tracker.createInstance<SetElementContext>(_ctx, getState());
  enterRule(_localctx, 124, ANTLRv4Parser::RuleSetElement);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(712);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 87, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(708);
      match(ANTLRv4Parser::TOKEN_REF);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(709);
      match(ANTLRv4Parser::STRING_LITERAL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(710);
      range();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(711);
      match(ANTLRv4Parser::LEXER_CHAR_SET);
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BlockContext ------------------------------------------------------------------

ANTLRv4Parser::BlockContext::BlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::BlockContext::LPAREN() {
  return getToken(ANTLRv4Parser::LPAREN, 0);
}

ANTLRv4Parser::AltListContext* ANTLRv4Parser::BlockContext::altList() {
  return getRuleContext<ANTLRv4Parser::AltListContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::BlockContext::RPAREN() {
  return getToken(ANTLRv4Parser::RPAREN, 0);
}

tree::TerminalNode* ANTLRv4Parser::BlockContext::COLON() {
  return getToken(ANTLRv4Parser::COLON, 0);
}

ANTLRv4Parser::OptionsSpecContext* ANTLRv4Parser::BlockContext::optionsSpec() {
  return getRuleContext<ANTLRv4Parser::OptionsSpecContext>(0);
}

std::vector<ANTLRv4Parser::RuleActionContext *> ANTLRv4Parser::BlockContext::ruleAction() {
  return getRuleContexts<ANTLRv4Parser::RuleActionContext>();
}

ANTLRv4Parser::RuleActionContext* ANTLRv4Parser::BlockContext::ruleAction(size_t i) {
  return getRuleContext<ANTLRv4Parser::RuleActionContext>(i);
}


size_t ANTLRv4Parser::BlockContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleBlock;
}

void ANTLRv4Parser::BlockContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterBlock(this);
}

void ANTLRv4Parser::BlockContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitBlock(this);
}


antlrcpp::Any ANTLRv4Parser::BlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitBlock(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::BlockContext* ANTLRv4Parser::block() {
  BlockContext *_localctx = _tracker.createInstance<BlockContext>(_ctx, getState());
  enterRule(_localctx, 126, ANTLRv4Parser::RuleBlock);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(714);
    match(ANTLRv4Parser::LPAREN);
    setState(725);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << ANTLRv4Parser::OPTIONS)
      | (1ULL << ANTLRv4Parser::COLON)
      | (1ULL << ANTLRv4Parser::AT))) != 0)) {
      setState(716);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == ANTLRv4Parser::OPTIONS) {
        setState(715);
        optionsSpec();
      }
      setState(721);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == ANTLRv4Parser::AT) {
        setState(718);
        ruleAction();
        setState(723);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(724);
      match(ANTLRv4Parser::COLON);
    }
    setState(727);
    altList();
    setState(728);
    match(ANTLRv4Parser::RPAREN);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RulerefContext ------------------------------------------------------------------

ANTLRv4Parser::RulerefContext::RulerefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::RulerefContext::RULE_REF() {
  return getToken(ANTLRv4Parser::RULE_REF, 0);
}

ANTLRv4Parser::ArgActionBlockContext* ANTLRv4Parser::RulerefContext::argActionBlock() {
  return getRuleContext<ANTLRv4Parser::ArgActionBlockContext>(0);
}


size_t ANTLRv4Parser::RulerefContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleRuleref;
}

void ANTLRv4Parser::RulerefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRuleref(this);
}

void ANTLRv4Parser::RulerefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRuleref(this);
}


antlrcpp::Any ANTLRv4Parser::RulerefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitRuleref(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::RulerefContext* ANTLRv4Parser::ruleref() {
  RulerefContext *_localctx = _tracker.createInstance<RulerefContext>(_ctx, getState());
  enterRule(_localctx, 128, ANTLRv4Parser::RuleRuleref);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(730);
    match(ANTLRv4Parser::RULE_REF);
    setState(732);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == ANTLRv4Parser::BEGIN_ARG_ACTION) {
      setState(731);
      argActionBlock();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RangeContext ------------------------------------------------------------------

ANTLRv4Parser::RangeContext::RangeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::RangeContext::STRING_LITERAL() {
  return getTokens(ANTLRv4Parser::STRING_LITERAL);
}

tree::TerminalNode* ANTLRv4Parser::RangeContext::STRING_LITERAL(size_t i) {
  return getToken(ANTLRv4Parser::STRING_LITERAL, i);
}

tree::TerminalNode* ANTLRv4Parser::RangeContext::RANGE() {
  return getToken(ANTLRv4Parser::RANGE, 0);
}


size_t ANTLRv4Parser::RangeContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleRange;
}

void ANTLRv4Parser::RangeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRange(this);
}

void ANTLRv4Parser::RangeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRange(this);
}


antlrcpp::Any ANTLRv4Parser::RangeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitRange(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::RangeContext* ANTLRv4Parser::range() {
  RangeContext *_localctx = _tracker.createInstance<RangeContext>(_ctx, getState());
  enterRule(_localctx, 130, ANTLRv4Parser::RuleRange);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(734);
    match(ANTLRv4Parser::STRING_LITERAL);
    setState(735);
    match(ANTLRv4Parser::RANGE);
    setState(736);
    match(ANTLRv4Parser::STRING_LITERAL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TerminalContext ------------------------------------------------------------------

ANTLRv4Parser::TerminalContext::TerminalContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::TerminalContext::TOKEN_REF() {
  return getToken(ANTLRv4Parser::TOKEN_REF, 0);
}

ANTLRv4Parser::ElementOptionsContext* ANTLRv4Parser::TerminalContext::elementOptions() {
  return getRuleContext<ANTLRv4Parser::ElementOptionsContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::TerminalContext::STRING_LITERAL() {
  return getToken(ANTLRv4Parser::STRING_LITERAL, 0);
}


size_t ANTLRv4Parser::TerminalContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleTerminal;
}

void ANTLRv4Parser::TerminalContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTerminal(this);
}

void ANTLRv4Parser::TerminalContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTerminal(this);
}


antlrcpp::Any ANTLRv4Parser::TerminalContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitTerminal(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::TerminalContext* ANTLRv4Parser::terminal() {
  TerminalContext *_localctx = _tracker.createInstance<TerminalContext>(_ctx, getState());
  enterRule(_localctx, 132, ANTLRv4Parser::RuleTerminal);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(746);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case ANTLRv4Parser::TOKEN_REF: {
        enterOuterAlt(_localctx, 1);
        setState(738);
        match(ANTLRv4Parser::TOKEN_REF);
        setState(740);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == ANTLRv4Parser::LT) {
          setState(739);
          elementOptions();
        }
        break;
      }

      case ANTLRv4Parser::STRING_LITERAL: {
        enterOuterAlt(_localctx, 2);
        setState(742);
        match(ANTLRv4Parser::STRING_LITERAL);
        setState(744);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == ANTLRv4Parser::LT) {
          setState(743);
          elementOptions();
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ElementOptionsContext ------------------------------------------------------------------

ANTLRv4Parser::ElementOptionsContext::ElementOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::ElementOptionsContext::LT() {
  return getToken(ANTLRv4Parser::LT, 0);
}

std::vector<ANTLRv4Parser::ElementOptionContext *> ANTLRv4Parser::ElementOptionsContext::elementOption() {
  return getRuleContexts<ANTLRv4Parser::ElementOptionContext>();
}

ANTLRv4Parser::ElementOptionContext* ANTLRv4Parser::ElementOptionsContext::elementOption(size_t i) {
  return getRuleContext<ANTLRv4Parser::ElementOptionContext>(i);
}

tree::TerminalNode* ANTLRv4Parser::ElementOptionsContext::GT() {
  return getToken(ANTLRv4Parser::GT, 0);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::ElementOptionsContext::COMMA() {
  return getTokens(ANTLRv4Parser::COMMA);
}

tree::TerminalNode* ANTLRv4Parser::ElementOptionsContext::COMMA(size_t i) {
  return getToken(ANTLRv4Parser::COMMA, i);
}


size_t ANTLRv4Parser::ElementOptionsContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleElementOptions;
}

void ANTLRv4Parser::ElementOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterElementOptions(this);
}

void ANTLRv4Parser::ElementOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitElementOptions(this);
}


antlrcpp::Any ANTLRv4Parser::ElementOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitElementOptions(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ElementOptionsContext* ANTLRv4Parser::elementOptions() {
  ElementOptionsContext *_localctx = _tracker.createInstance<ElementOptionsContext>(_ctx, getState());
  enterRule(_localctx, 134, ANTLRv4Parser::RuleElementOptions);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(748);
    match(ANTLRv4Parser::LT);
    setState(749);
    elementOption();
    setState(754);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == ANTLRv4Parser::COMMA) {
      setState(750);
      match(ANTLRv4Parser::COMMA);
      setState(751);
      elementOption();
      setState(756);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(757);
    match(ANTLRv4Parser::GT);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ElementOptionContext ------------------------------------------------------------------

ANTLRv4Parser::ElementOptionContext::ElementOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

ANTLRv4Parser::QidContext* ANTLRv4Parser::ElementOptionContext::qid() {
  return getRuleContext<ANTLRv4Parser::QidContext>(0);
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::ElementOptionContext::id() {
  return getRuleContext<ANTLRv4Parser::IdContext>(0);
}

tree::TerminalNode* ANTLRv4Parser::ElementOptionContext::ASSIGN() {
  return getToken(ANTLRv4Parser::ASSIGN, 0);
}

tree::TerminalNode* ANTLRv4Parser::ElementOptionContext::STRING_LITERAL() {
  return getToken(ANTLRv4Parser::STRING_LITERAL, 0);
}


size_t ANTLRv4Parser::ElementOptionContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleElementOption;
}

void ANTLRv4Parser::ElementOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterElementOption(this);
}

void ANTLRv4Parser::ElementOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitElementOption(this);
}


antlrcpp::Any ANTLRv4Parser::ElementOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitElementOption(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::ElementOptionContext* ANTLRv4Parser::elementOption() {
  ElementOptionContext *_localctx = _tracker.createInstance<ElementOptionContext>(_ctx, getState());
  enterRule(_localctx, 136, ANTLRv4Parser::RuleElementOption);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(766);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 97, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(759);
      qid();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(760);
      id();
      setState(761);
      match(ANTLRv4Parser::ASSIGN);
      setState(764);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case ANTLRv4Parser::TOKEN_REF:
        case ANTLRv4Parser::RULE_REF: {
          setState(762);
          qid();
          break;
        }

        case ANTLRv4Parser::STRING_LITERAL: {
          setState(763);
          match(ANTLRv4Parser::STRING_LITERAL);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdContext ------------------------------------------------------------------

ANTLRv4Parser::IdContext::IdContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* ANTLRv4Parser::IdContext::RULE_REF() {
  return getToken(ANTLRv4Parser::RULE_REF, 0);
}

tree::TerminalNode* ANTLRv4Parser::IdContext::TOKEN_REF() {
  return getToken(ANTLRv4Parser::TOKEN_REF, 0);
}


size_t ANTLRv4Parser::IdContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleId;
}

void ANTLRv4Parser::IdContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterId(this);
}

void ANTLRv4Parser::IdContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitId(this);
}


antlrcpp::Any ANTLRv4Parser::IdContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitId(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::id() {
  IdContext *_localctx = _tracker.createInstance<IdContext>(_ctx, getState());
  enterRule(_localctx, 138, ANTLRv4Parser::RuleId);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(768);
    _la = _input->LA(1);
    if (!(_la == ANTLRv4Parser::TOKEN_REF

    || _la == ANTLRv4Parser::RULE_REF)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QidContext ------------------------------------------------------------------

ANTLRv4Parser::QidContext::QidContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<ANTLRv4Parser::IdContext *> ANTLRv4Parser::QidContext::id() {
  return getRuleContexts<ANTLRv4Parser::IdContext>();
}

ANTLRv4Parser::IdContext* ANTLRv4Parser::QidContext::id(size_t i) {
  return getRuleContext<ANTLRv4Parser::IdContext>(i);
}

std::vector<tree::TerminalNode *> ANTLRv4Parser::QidContext::DOT() {
  return getTokens(ANTLRv4Parser::DOT);
}

tree::TerminalNode* ANTLRv4Parser::QidContext::DOT(size_t i) {
  return getToken(ANTLRv4Parser::DOT, i);
}


size_t ANTLRv4Parser::QidContext::getRuleIndex() const {
  return ANTLRv4Parser::RuleQid;
}

void ANTLRv4Parser::QidContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterQid(this);
}

void ANTLRv4Parser::QidContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitQid(this);
}


antlrcpp::Any ANTLRv4Parser::QidContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<ANTLRv4ParserVisitor*>(visitor))
    return parserVisitor->visitQid(this);
  else
    return visitor->visitChildren(this);
}

ANTLRv4Parser::QidContext* ANTLRv4Parser::qid() {
  QidContext *_localctx = _tracker.createInstance<QidContext>(_ctx, getState());
  enterRule(_localctx, 140, ANTLRv4Parser::RuleQid);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(770);
    id();
    setState(775);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == ANTLRv4Parser::DOT) {
      setState(771);
      match(ANTLRv4Parser::DOT);
      setState(772);
      id();
      setState(777);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

// Static vars and initialization.
std::vector<dfa::DFA> ANTLRv4Parser::_decisionToDFA;
atn::PredictionContextCache ANTLRv4Parser::_sharedContextCache;

// We own the ATN which in turn owns the ATN states.
atn::ATN ANTLRv4Parser::_atn;
std::vector<uint16_t> ANTLRv4Parser::_serializedATN;

std::vector<std::string> ANTLRv4Parser::_ruleNames = {
  "grammarSpec", "grammarType", "prequelConstruct", "optionsSpec", "option", 
  "optionValue", "delegateGrammars", "delegateGrammar", "tokensSpec", "actionBlock", 
  "actionExpression", "actionScopeExpression", "argActionBlock", "argActionParameters", 
  "argActionParameter", "argActionParameterType", "argActionParameterTypePart", 
  "ignored", "action", "actionScopeName", "modeSpec", "rules", "ruleSpec", 
  "parserRuleSpec", "exceptionGroup", "exceptionHandler", "finallyClause", 
  "rulePrequels", "rulePrequel", "ruleReturns", "throwsSpec", "localsSpec", 
  "ruleAction", "ruleModifiers", "ruleModifier", "ruleBlock", "ruleAltList", 
  "labeledAlt", "lexerRule", "lexerRuleBlock", "lexerAltList", "lexerAlt", 
  "lexerElements", "lexerElement", "labeledLexerElement", "lexerBlock", 
  "lexerCommands", "lexerCommand", "lexerCommandName", "lexerCommandExpr", 
  "altList", "alternative", "elements", "element", "labeledElement", "ebnf", 
  "blockSuffix", "ebnfSuffix", "lexerAtom", "atom", "notSet", "blockSet", 
  "setElement", "block", "ruleref", "range", "terminal", "elementOptions", 
  "elementOption", "id", "qid"
};

std::vector<std::string> ANTLRv4Parser::_literalNames = {
  "", "", "", "", "", "", "", "", "", "'{'", "", "", "'import'", "'fragment'", 
  "'lexer'", "'parser'", "'grammar'", "'protected'", "'public'", "'private'", 
  "'returns'", "'locals'", "'throws'", "'catch'", "'finally'", "'mode'", 
  "", "", "", "';'", "", "", "'->'", "", "", "", "'?'", "'*'", "'+'", "'+='", 
  "'|'", "'$'", "", "'..'", "'@'", "'#'", "'~'", "", "", "", "", "", "", 
  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
  "", "", "", "", "", "", "'-'"
};

std::vector<std::string> ANTLRv4Parser::_symbolicNames = {
  "", "TOKEN_REF", "RULE_REF", "LEXER_CHAR_SET", "DOC_COMMENT", "BLOCK_COMMENT", 
  "LINE_COMMENT", "DOUBLE_QUOTE_STRING_LITERAL", "BEGIN_ARG_ACTION", "BEGIN_ACTION", 
  "OPTIONS", "TOKENS", "IMPORT", "FRAGMENT", "LEXER", "PARSER", "GRAMMAR", 
  "PROTECTED", "PUBLIC", "PRIVATE", "RETURNS", "LOCALS", "THROWS", "CATCH", 
  "FINALLY", "MODE", "COLON", "COLONCOLON", "COMMA", "SEMI", "LPAREN", "RPAREN", 
  "RARROW", "LT", "GT", "ASSIGN", "QUESTION", "STAR", "PLUS", "PLUS_ASSIGN", 
  "OR", "DOLLAR", "DOT", "RANGE", "AT", "POUND", "NOT", "RBRACE", "ID", 
  "INT", "STRING_LITERAL", "WS", "ERRCHAR", "ARG_ACTION_LT", "ARG_ACTION_GT", 
  "ARG_ACTION_LPAREN", "ARG_ACTION_RPAREN", "ARG_ACTION_EQUALS", "ARG_ACTION_COMMA", 
  "ARG_ACTION_ESCAPE", "ARG_ACTION_WORD", "ARG_ACTION_ELEMENT", "ARG_ACTION_TEXT", 
  "ARG_ACTION_WS", "ARG_ACTION_NEWLINE", "END_ARG_ACTION", "ACTION_DOT", 
  "ACTION_LT", "ACTION_GT", "ACTION_LPAREN", "ACTION_RPAREN", "ACTION_LBRACK", 
  "ACTION_RBRACK", "ACTION_EQUALS", "ACTION_COMMA", "ACTION_COLON2", "ACTION_COLON", 
  "ACTION_MINUS", "ACTION_ESCAPE", "ACTION_WORD", "ACTION_REFERENCE", "ACTION_COMMENT", 
  "ACTION_LITERAL", "ACTION_TEXT", "ACTION_WS", "ACTION_NEWLINE", "END_ACTION", 
  "COMBINED"
};

dfa::Vocabulary ANTLRv4Parser::_vocabulary(_literalNames, _symbolicNames);

std::vector<std::string> ANTLRv4Parser::_tokenNames;

ANTLRv4Parser::Initializer::Initializer() {
	for (size_t i = 0; i < _symbolicNames.size(); ++i) {
		std::string name = _vocabulary.getLiteralName(i);
		if (name.empty()) {
			name = _vocabulary.getSymbolicName(i);
		}

		if (name.empty()) {
			_tokenNames.push_back("<INVALID>");
		} else {
      _tokenNames.push_back(name);
    }
	}

  _serializedATN = {
    0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, 
    0x3, 0x59, 0x30d, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, 
    0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7, 
    0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb, 
    0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9, 0xe, 
    0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, 0x11, 0x4, 
    0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, 0x4, 0x15, 
    0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4, 0x18, 0x9, 
    0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, 
    0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4, 
    0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22, 
    0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, 
    0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28, 
    0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, 0x4, 
    0x2c, 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f, 
    0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, 0x9, 
    0x32, 0x4, 0x33, 0x9, 0x33, 0x4, 0x34, 0x9, 0x34, 0x4, 0x35, 0x9, 0x35, 
    0x4, 0x36, 0x9, 0x36, 0x4, 0x37, 0x9, 0x37, 0x4, 0x38, 0x9, 0x38, 0x4, 
    0x39, 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, 0x4, 0x3b, 0x9, 0x3b, 0x4, 0x3c, 
    0x9, 0x3c, 0x4, 0x3d, 0x9, 0x3d, 0x4, 0x3e, 0x9, 0x3e, 0x4, 0x3f, 0x9, 
    0x3f, 0x4, 0x40, 0x9, 0x40, 0x4, 0x41, 0x9, 0x41, 0x4, 0x42, 0x9, 0x42, 
    0x4, 0x43, 0x9, 0x43, 0x4, 0x44, 0x9, 0x44, 0x4, 0x45, 0x9, 0x45, 0x4, 
    0x46, 0x9, 0x46, 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, 0x9, 0x48, 0x3, 0x2, 
    0x5, 0x2, 0x92, 0xa, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x7, 
    0x2, 0x98, 0xa, 0x2, 0xc, 0x2, 0xe, 0x2, 0x9b, 0xb, 0x2, 0x3, 0x2, 0x3, 
    0x2, 0x7, 0x2, 0x9f, 0xa, 0x2, 0xc, 0x2, 0xe, 0x2, 0xa2, 0xb, 0x2, 0x3, 
    0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 
    0x3, 0xab, 0xa, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x5, 0x4, 
    0xb1, 0xa, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x7, 0x5, 0xb7, 
    0xa, 0x5, 0xc, 0x5, 0xe, 0x5, 0xba, 0xb, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 
    0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 
    0x7, 0x5, 0x7, 0xc6, 0xa, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 
    0x7, 0x8, 0xcc, 0xa, 0x8, 0xc, 0x8, 0xe, 0x8, 0xcf, 0xb, 0x8, 0x3, 0x8, 
    0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x5, 0x9, 
    0xd8, 0xa, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x7, 0xa, 0xde, 
    0xa, 0xa, 0xc, 0xa, 0xe, 0xa, 0xe1, 0xb, 0xa, 0x3, 0xa, 0x5, 0xa, 0xe4, 
    0xa, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 
    0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 
    0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 
    0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x7, 0xb, 
    0x100, 0xa, 0xb, 0xc, 0xb, 0xe, 0xb, 0x103, 0xb, 0xb, 0x3, 0xb, 0x3, 
    0xb, 0x3, 0xc, 0x3, 0xc, 0x7, 0xc, 0x109, 0xa, 0xc, 0xc, 0xc, 0xe, 0xc, 
    0x10c, 0xb, 0xc, 0x3, 0xc, 0x3, 0xc, 0x7, 0xc, 0x110, 0xa, 0xc, 0xc, 
    0xc, 0xe, 0xc, 0x113, 0xb, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xd, 0x3, 0xd, 
    0x7, 0xd, 0x119, 0xa, 0xd, 0xc, 0xd, 0xe, 0xd, 0x11c, 0xb, 0xd, 0x3, 
    0xd, 0x3, 0xd, 0x7, 0xd, 0x120, 0xa, 0xd, 0xc, 0xd, 0xe, 0xd, 0x123, 
    0xb, 0xd, 0x3, 0xd, 0x3, 0xd, 0x7, 0xd, 0x127, 0xa, 0xd, 0xc, 0xd, 0xe, 
    0xd, 0x12a, 0xb, 0xd, 0x5, 0xd, 0x12c, 0xa, 0xd, 0x3, 0xd, 0x3, 0xd, 
    0x7, 0xd, 0x130, 0xa, 0xd, 0xc, 0xd, 0xe, 0xd, 0x133, 0xb, 0xd, 0x3, 
    0xd, 0x3, 0xd, 0x7, 0xd, 0x137, 0xa, 0xd, 0xc, 0xd, 0xe, 0xd, 0x13a, 
    0xb, 0xd, 0x5, 0xd, 0x13c, 0xa, 0xd, 0x3, 0xd, 0x3, 0xd, 0x7, 0xd, 0x140, 
    0xa, 0xd, 0xc, 0xd, 0xe, 0xd, 0x143, 0xb, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 
    0xe, 0x3, 0xe, 0x7, 0xe, 0x149, 0xa, 0xe, 0xc, 0xe, 0xe, 0xe, 0x14c, 
    0xb, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xf, 0x3, 0xf, 0x7, 0xf, 0x152, 0xa, 
    0xf, 0xc, 0xf, 0xe, 0xf, 0x155, 0xb, 0xf, 0x3, 0xf, 0x3, 0xf, 0x7, 0xf, 
    0x159, 0xa, 0xf, 0xc, 0xf, 0xe, 0xf, 0x15c, 0xb, 0xf, 0x3, 0xf, 0x3, 
    0xf, 0x7, 0xf, 0x160, 0xa, 0xf, 0xc, 0xf, 0xe, 0xf, 0x163, 0xb, 0xf, 
    0x3, 0xf, 0x3, 0xf, 0x7, 0xf, 0x167, 0xa, 0xf, 0xc, 0xf, 0xe, 0xf, 0x16a, 
    0xb, 0xf, 0x7, 0xf, 0x16c, 0xa, 0xf, 0xc, 0xf, 0xe, 0xf, 0x16f, 0xb, 
    0xf, 0x5, 0xf, 0x171, 0xa, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x5, 
    0x10, 0x176, 0xa, 0x10, 0x3, 0x10, 0x7, 0x10, 0x179, 0xa, 0x10, 0xc, 
    0x10, 0xe, 0x10, 0x17c, 0xb, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, 0x11, 
    0x3, 0x11, 0x7, 0x11, 0x182, 0xa, 0x11, 0xc, 0x11, 0xe, 0x11, 0x185, 
    0xb, 0x11, 0x3, 0x11, 0x7, 0x11, 0x188, 0xa, 0x11, 0xc, 0x11, 0xe, 0x11, 
    0x18b, 0xb, 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x5, 0x12, 0x190, 
    0xa, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x5, 0x12, 0x195, 0xa, 0x12, 
    0x3, 0x12, 0x5, 0x12, 0x198, 0xa, 0x12, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 
    0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x5, 0x14, 0x1a0, 0xa, 0x14, 0x3, 0x14, 
    0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x5, 0x15, 0x1a8, 
    0xa, 0x15, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x6, 0x16, 0x1ae, 
    0xa, 0x16, 0xd, 0x16, 0xe, 0x16, 0x1af, 0x3, 0x17, 0x7, 0x17, 0x1b3, 
    0xa, 0x17, 0xc, 0x17, 0xe, 0x17, 0x1b6, 0xb, 0x17, 0x3, 0x18, 0x3, 0x18, 
    0x5, 0x18, 0x1ba, 0xa, 0x18, 0x3, 0x19, 0x5, 0x19, 0x1bd, 0xa, 0x19, 
    0x3, 0x19, 0x5, 0x19, 0x1c0, 0xa, 0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 
    0x1c4, 0xa, 0x19, 0x3, 0x19, 0x5, 0x19, 0x1c7, 0xa, 0x19, 0x3, 0x19, 
    0x5, 0x19, 0x1ca, 0xa, 0x19, 0x3, 0x19, 0x5, 0x19, 0x1cd, 0xa, 0x19, 
    0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 
    0x19, 0x3, 0x1a, 0x7, 0x1a, 0x1d7, 0xa, 0x1a, 0xc, 0x1a, 0xe, 0x1a, 
    0x1da, 0xb, 0x1a, 0x3, 0x1a, 0x5, 0x1a, 0x1dd, 0xa, 0x1a, 0x3, 0x1b, 
    0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 
    0x1d, 0x7, 0x1d, 0x1e7, 0xa, 0x1d, 0xc, 0x1d, 0xe, 0x1d, 0x1ea, 0xb, 
    0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x5, 0x1e, 0x1ee, 0xa, 0x1e, 0x3, 0x1f, 
    0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x7, 
    0x20, 0x1f7, 0xa, 0x20, 0xc, 0x20, 0xe, 0x20, 0x1fa, 0xb, 0x20, 0x3, 
    0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 
    0x3, 0x23, 0x6, 0x23, 0x204, 0xa, 0x23, 0xd, 0x23, 0xe, 0x23, 0x205, 
    0x3, 0x24, 0x3, 0x24, 0x3, 0x25, 0x3, 0x25, 0x3, 0x26, 0x3, 0x26, 0x3, 
    0x26, 0x7, 0x26, 0x20f, 0xa, 0x26, 0xc, 0x26, 0xe, 0x26, 0x212, 0xb, 
    0x26, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x5, 0x27, 0x217, 0xa, 0x27, 
    0x3, 0x27, 0x3, 0x27, 0x3, 0x28, 0x5, 0x28, 0x21c, 0xa, 0x28, 0x3, 0x28, 
    0x5, 0x28, 0x21f, 0xa, 0x28, 0x3, 0x28, 0x3, 0x28, 0x3, 0x28, 0x3, 0x28, 
    0x3, 0x28, 0x3, 0x29, 0x3, 0x29, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2a, 0x7, 
    0x2a, 0x22b, 0xa, 0x2a, 0xc, 0x2a, 0xe, 0x2a, 0x22e, 0xb, 0x2a, 0x3, 
    0x2b, 0x5, 0x2b, 0x231, 0xa, 0x2b, 0x3, 0x2b, 0x5, 0x2b, 0x234, 0xa, 
    0x2b, 0x3, 0x2c, 0x6, 0x2c, 0x237, 0xa, 0x2c, 0xd, 0x2c, 0xe, 0x2c, 
    0x238, 0x3, 0x2d, 0x3, 0x2d, 0x5, 0x2d, 0x23d, 0xa, 0x2d, 0x3, 0x2d, 
    0x3, 0x2d, 0x5, 0x2d, 0x241, 0xa, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x5, 0x2d, 
    0x245, 0xa, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x5, 0x2d, 0x249, 0xa, 0x2d, 
    0x5, 0x2d, 0x24b, 0xa, 0x2d, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 
    0x5, 0x2e, 0x251, 0xa, 0x2e, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 
    0x3, 0x30, 0x3, 0x30, 0x3, 0x30, 0x3, 0x30, 0x7, 0x30, 0x25b, 0xa, 0x30, 
    0xc, 0x30, 0xe, 0x30, 0x25e, 0xb, 0x30, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 
    0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x5, 0x31, 0x266, 0xa, 0x31, 0x3, 0x32, 
    0x3, 0x32, 0x5, 0x32, 0x26a, 0xa, 0x32, 0x3, 0x33, 0x3, 0x33, 0x5, 0x33, 
    0x26e, 0xa, 0x33, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x7, 0x34, 0x273, 
    0xa, 0x34, 0xc, 0x34, 0xe, 0x34, 0x276, 0xb, 0x34, 0x3, 0x35, 0x3, 0x35, 
    0x5, 0x35, 0x27a, 0xa, 0x35, 0x3, 0x36, 0x6, 0x36, 0x27d, 0xa, 0x36, 
    0xd, 0x36, 0xe, 0x36, 0x27e, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x5, 0x37, 
    0x284, 0xa, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x5, 0x37, 0x289, 
    0xa, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x5, 0x37, 0x28e, 0xa, 0x37, 
    0x5, 0x37, 0x290, 0xa, 0x37, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 
    0x5, 0x38, 0x296, 0xa, 0x38, 0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x5, 0x39, 
    0x29b, 0xa, 0x39, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3c, 
    0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x5, 
    0x3c, 0x2a8, 0xa, 0x3c, 0x5, 0x3c, 0x2aa, 0xa, 0x3c, 0x3, 0x3d, 0x3, 
    0x3d, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3d, 0x5, 0x3d, 0x2b2, 
    0xa, 0x3d, 0x5, 0x3d, 0x2b4, 0xa, 0x3d, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 
    0x3, 0x3e, 0x5, 0x3e, 0x2ba, 0xa, 0x3e, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 
    0x3, 0x3f, 0x7, 0x3f, 0x2c0, 0xa, 0x3f, 0xc, 0x3f, 0xe, 0x3f, 0x2c3, 
    0xb, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x40, 0x3, 0x40, 0x3, 0x40, 0x3, 
    0x40, 0x5, 0x40, 0x2cb, 0xa, 0x40, 0x3, 0x41, 0x3, 0x41, 0x5, 0x41, 
    0x2cf, 0xa, 0x41, 0x3, 0x41, 0x7, 0x41, 0x2d2, 0xa, 0x41, 0xc, 0x41, 
    0xe, 0x41, 0x2d5, 0xb, 0x41, 0x3, 0x41, 0x5, 0x41, 0x2d8, 0xa, 0x41, 
    0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x42, 0x3, 0x42, 0x5, 0x42, 0x2df, 
    0xa, 0x42, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x44, 0x3, 
    0x44, 0x5, 0x44, 0x2e7, 0xa, 0x44, 0x3, 0x44, 0x3, 0x44, 0x5, 0x44, 
    0x2eb, 0xa, 0x44, 0x5, 0x44, 0x2ed, 0xa, 0x44, 0x3, 0x45, 0x3, 0x45, 
    0x3, 0x45, 0x3, 0x45, 0x7, 0x45, 0x2f3, 0xa, 0x45, 0xc, 0x45, 0xe, 0x45, 
    0x2f6, 0xb, 0x45, 0x3, 0x45, 0x3, 0x45, 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 
    0x3, 0x46, 0x3, 0x46, 0x5, 0x46, 0x2ff, 0xa, 0x46, 0x5, 0x46, 0x301, 
    0xa, 0x46, 0x3, 0x47, 0x3, 0x47, 0x3, 0x48, 0x3, 0x48, 0x3, 0x48, 0x7, 
    0x48, 0x308, 0xa, 0x48, 0xc, 0x48, 0xe, 0x48, 0x30b, 0xb, 0x48, 0x3, 
    0x48, 0x2, 0x2, 0x49, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 
    0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 
    0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 
    0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 
    0x5c, 0x5e, 0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 
    0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e, 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 
    0x8c, 0x8e, 0x2, 0x8, 0x3, 0x2, 0x37, 0x42, 0x5, 0x2, 0x41, 0x42, 0x53, 
    0x53, 0x56, 0x57, 0x4, 0x2, 0xf, 0xf, 0x13, 0x15, 0x4, 0x2, 0x25, 0x25, 
    0x29, 0x29, 0x3, 0x2, 0x26, 0x28, 0x3, 0x2, 0x3, 0x4, 0x2, 0x351, 0x2, 
    0x91, 0x3, 0x2, 0x2, 0x2, 0x4, 0xaa, 0x3, 0x2, 0x2, 0x2, 0x6, 0xb0, 
    0x3, 0x2, 0x2, 0x2, 0x8, 0xb2, 0x3, 0x2, 0x2, 0x2, 0xa, 0xbd, 0x3, 0x2, 
    0x2, 0x2, 0xc, 0xc5, 0x3, 0x2, 0x2, 0x2, 0xe, 0xc7, 0x3, 0x2, 0x2, 0x2, 
    0x10, 0xd7, 0x3, 0x2, 0x2, 0x2, 0x12, 0xd9, 0x3, 0x2, 0x2, 0x2, 0x14, 
    0xe7, 0x3, 0x2, 0x2, 0x2, 0x16, 0x106, 0x3, 0x2, 0x2, 0x2, 0x18, 0x116, 
    0x3, 0x2, 0x2, 0x2, 0x1a, 0x146, 0x3, 0x2, 0x2, 0x2, 0x1c, 0x14f, 0x3, 
    0x2, 0x2, 0x2, 0x1e, 0x175, 0x3, 0x2, 0x2, 0x2, 0x20, 0x17f, 0x3, 0x2, 
    0x2, 0x2, 0x22, 0x197, 0x3, 0x2, 0x2, 0x2, 0x24, 0x199, 0x3, 0x2, 0x2, 
    0x2, 0x26, 0x19b, 0x3, 0x2, 0x2, 0x2, 0x28, 0x1a7, 0x3, 0x2, 0x2, 0x2, 
    0x2a, 0x1a9, 0x3, 0x2, 0x2, 0x2, 0x2c, 0x1b4, 0x3, 0x2, 0x2, 0x2, 0x2e, 
    0x1b9, 0x3, 0x2, 0x2, 0x2, 0x30, 0x1bc, 0x3, 0x2, 0x2, 0x2, 0x32, 0x1d8, 
    0x3, 0x2, 0x2, 0x2, 0x34, 0x1de, 0x3, 0x2, 0x2, 0x2, 0x36, 0x1e2, 0x3, 
    0x2, 0x2, 0x2, 0x38, 0x1e8, 0x3, 0x2, 0x2, 0x2, 0x3a, 0x1ed, 0x3, 0x2, 
    0x2, 0x2, 0x3c, 0x1ef, 0x3, 0x2, 0x2, 0x2, 0x3e, 0x1f2, 0x3, 0x2, 0x2, 
    0x2, 0x40, 0x1fb, 0x3, 0x2, 0x2, 0x2, 0x42, 0x1fe, 0x3, 0x2, 0x2, 0x2, 
    0x44, 0x203, 0x3, 0x2, 0x2, 0x2, 0x46, 0x207, 0x3, 0x2, 0x2, 0x2, 0x48, 
    0x209, 0x3, 0x2, 0x2, 0x2, 0x4a, 0x20b, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x213, 
    0x3, 0x2, 0x2, 0x2, 0x4e, 0x21b, 0x3, 0x2, 0x2, 0x2, 0x50, 0x225, 0x3, 
    0x2, 0x2, 0x2, 0x52, 0x227, 0x3, 0x2, 0x2, 0x2, 0x54, 0x230, 0x3, 0x2, 
    0x2, 0x2, 0x56, 0x236, 0x3, 0x2, 0x2, 0x2, 0x58, 0x24a, 0x3, 0x2, 0x2, 
    0x2, 0x5a, 0x24c, 0x3, 0x2, 0x2, 0x2, 0x5c, 0x252, 0x3, 0x2, 0x2, 0x2, 
    0x5e, 0x256, 0x3, 0x2, 0x2, 0x2, 0x60, 0x265, 0x3, 0x2, 0x2, 0x2, 0x62, 
    0x269, 0x3, 0x2, 0x2, 0x2, 0x64, 0x26d, 0x3, 0x2, 0x2, 0x2, 0x66, 0x26f, 
    0x3, 0x2, 0x2, 0x2, 0x68, 0x279, 0x3, 0x2, 0x2, 0x2, 0x6a, 0x27c, 0x3, 
    0x2, 0x2, 0x2, 0x6c, 0x28f, 0x3, 0x2, 0x2, 0x2, 0x6e, 0x291, 0x3, 0x2, 
    0x2, 0x2, 0x70, 0x297, 0x3, 0x2, 0x2, 0x2, 0x72, 0x29c, 0x3, 0x2, 0x2, 
    0x2, 0x74, 0x29e, 0x3, 0x2, 0x2, 0x2, 0x76, 0x2a9, 0x3, 0x2, 0x2, 0x2, 
    0x78, 0x2b3, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x2b9, 0x3, 0x2, 0x2, 0x2, 0x7c, 
    0x2bb, 0x3, 0x2, 0x2, 0x2, 0x7e, 0x2ca, 0x3, 0x2, 0x2, 0x2, 0x80, 0x2cc, 
    0x3, 0x2, 0x2, 0x2, 0x82, 0x2dc, 0x3, 0x2, 0x2, 0x2, 0x84, 0x2e0, 0x3, 
    0x2, 0x2, 0x2, 0x86, 0x2ec, 0x3, 0x2, 0x2, 0x2, 0x88, 0x2ee, 0x3, 0x2, 
    0x2, 0x2, 0x8a, 0x300, 0x3, 0x2, 0x2, 0x2, 0x8c, 0x302, 0x3, 0x2, 0x2, 
    0x2, 0x8e, 0x304, 0x3, 0x2, 0x2, 0x2, 0x90, 0x92, 0x7, 0x6, 0x2, 0x2, 
    0x91, 0x90, 0x3, 0x2, 0x2, 0x2, 0x91, 0x92, 0x3, 0x2, 0x2, 0x2, 0x92, 
    0x93, 0x3, 0x2, 0x2, 0x2, 0x93, 0x94, 0x5, 0x4, 0x3, 0x2, 0x94, 0x95, 
    0x5, 0x8c, 0x47, 0x2, 0x95, 0x99, 0x7, 0x1f, 0x2, 0x2, 0x96, 0x98, 0x5, 
    0x6, 0x4, 0x2, 0x97, 0x96, 0x3, 0x2, 0x2, 0x2, 0x98, 0x9b, 0x3, 0x2, 
    0x2, 0x2, 0x99, 0x97, 0x3, 0x2, 0x2, 0x2, 0x99, 0x9a, 0x3, 0x2, 0x2, 
    0x2, 0x9a, 0x9c, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x99, 0x3, 0x2, 0x2, 0x2, 
    0x9c, 0xa0, 0x5, 0x2c, 0x17, 0x2, 0x9d, 0x9f, 0x5, 0x2a, 0x16, 0x2, 
    0x9e, 0x9d, 0x3, 0x2, 0x2, 0x2, 0x9f, 0xa2, 0x3, 0x2, 0x2, 0x2, 0xa0, 
    0x9e, 0x3, 0x2, 0x2, 0x2, 0xa0, 0xa1, 0x3, 0x2, 0x2, 0x2, 0xa1, 0xa3, 
    0x3, 0x2, 0x2, 0x2, 0xa2, 0xa0, 0x3, 0x2, 0x2, 0x2, 0xa3, 0xa4, 0x7, 
    0x2, 0x2, 0x3, 0xa4, 0x3, 0x3, 0x2, 0x2, 0x2, 0xa5, 0xa6, 0x7, 0x10, 
    0x2, 0x2, 0xa6, 0xab, 0x7, 0x12, 0x2, 0x2, 0xa7, 0xa8, 0x7, 0x11, 0x2, 
    0x2, 0xa8, 0xab, 0x7, 0x12, 0x2, 0x2, 0xa9, 0xab, 0x7, 0x12, 0x2, 0x2, 
    0xaa, 0xa5, 0x3, 0x2, 0x2, 0x2, 0xaa, 0xa7, 0x3, 0x2, 0x2, 0x2, 0xaa, 
    0xa9, 0x3, 0x2, 0x2, 0x2, 0xab, 0x5, 0x3, 0x2, 0x2, 0x2, 0xac, 0xb1, 
    0x5, 0x8, 0x5, 0x2, 0xad, 0xb1, 0x5, 0xe, 0x8, 0x2, 0xae, 0xb1, 0x5, 
    0x12, 0xa, 0x2, 0xaf, 0xb1, 0x5, 0x26, 0x14, 0x2, 0xb0, 0xac, 0x3, 0x2, 
    0x2, 0x2, 0xb0, 0xad, 0x3, 0x2, 0x2, 0x2, 0xb0, 0xae, 0x3, 0x2, 0x2, 
    0x2, 0xb0, 0xaf, 0x3, 0x2, 0x2, 0x2, 0xb1, 0x7, 0x3, 0x2, 0x2, 0x2, 
    0xb2, 0xb8, 0x7, 0xc, 0x2, 0x2, 0xb3, 0xb4, 0x5, 0xa, 0x6, 0x2, 0xb4, 
    0xb5, 0x7, 0x1f, 0x2, 0x2, 0xb5, 0xb7, 0x3, 0x2, 0x2, 0x2, 0xb6, 0xb3, 
    0x3, 0x2, 0x2, 0x2, 0xb7, 0xba, 0x3, 0x2, 0x2, 0x2, 0xb8, 0xb6, 0x3, 
    0x2, 0x2, 0x2, 0xb8, 0xb9, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xbb, 0x3, 0x2, 
    0x2, 0x2, 0xba, 0xb8, 0x3, 0x2, 0x2, 0x2, 0xbb, 0xbc, 0x7, 0x31, 0x2, 
    0x2, 0xbc, 0x9, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xbe, 0x5, 0x8c, 0x47, 0x2, 
    0xbe, 0xbf, 0x7, 0x25, 0x2, 0x2, 0xbf, 0xc0, 0x5, 0xc, 0x7, 0x2, 0xc0, 
    0xb, 0x3, 0x2, 0x2, 0x2, 0xc1, 0xc6, 0x5, 0x8e, 0x48, 0x2, 0xc2, 0xc6, 
    0x7, 0x34, 0x2, 0x2, 0xc3, 0xc6, 0x7, 0x33, 0x2, 0x2, 0xc4, 0xc6, 0x7, 
    0x27, 0x2, 0x2, 0xc5, 0xc1, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc2, 0x3, 0x2, 
    0x2, 0x2, 0xc5, 0xc3, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc4, 0x3, 0x2, 0x2, 
    0x2, 0xc6, 0xd, 0x3, 0x2, 0x2, 0x2, 0xc7, 0xc8, 0x7, 0xe, 0x2, 0x2, 
    0xc8, 0xcd, 0x5, 0x10, 0x9, 0x2, 0xc9, 0xca, 0x7, 0x1e, 0x2, 0x2, 0xca, 
    0xcc, 0x5, 0x10, 0x9, 0x2, 0xcb, 0xc9, 0x3, 0x2, 0x2, 0x2, 0xcc, 0xcf, 
    0x3, 0x2, 0x2, 0x2, 0xcd, 0xcb, 0x3, 0x2, 0x2, 0x2, 0xcd, 0xce, 0x3, 
    0x2, 0x2, 0x2, 0xce, 0xd0, 0x3, 0x2, 0x2, 0x2, 0xcf, 0xcd, 0x3, 0x2, 
    0x2, 0x2, 0xd0, 0xd1, 0x7, 0x1f, 0x2, 0x2, 0xd1, 0xf, 0x3, 0x2, 0x2, 
    0x2, 0xd2, 0xd3, 0x5, 0x8c, 0x47, 0x2, 0xd3, 0xd4, 0x7, 0x25, 0x2, 0x2, 
    0xd4, 0xd5, 0x5, 0x8c, 0x47, 0x2, 0xd5, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xd6, 
    0xd8, 0x5, 0x8c, 0x47, 0x2, 0xd7, 0xd2, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd6, 
    0x3, 0x2, 0x2, 0x2, 0xd8, 0x11, 0x3, 0x2, 0x2, 0x2, 0xd9, 0xda, 0x7, 
    0xd, 0x2, 0x2, 0xda, 0xdf, 0x5, 0x8c, 0x47, 0x2, 0xdb, 0xdc, 0x7, 0x1e, 
    0x2, 0x2, 0xdc, 0xde, 0x5, 0x8c, 0x47, 0x2, 0xdd, 0xdb, 0x3, 0x2, 0x2, 
    0x2, 0xde, 0xe1, 0x3, 0x2, 0x2, 0x2, 0xdf, 0xdd, 0x3, 0x2, 0x2, 0x2, 
    0xdf, 0xe0, 0x3, 0x2, 0x2, 0x2, 0xe0, 0xe3, 0x3, 0x2, 0x2, 0x2, 0xe1, 
    0xdf, 0x3, 0x2, 0x2, 0x2, 0xe2, 0xe4, 0x7, 0x1e, 0x2, 0x2, 0xe3, 0xe2, 
    0x3, 0x2, 0x2, 0x2, 0xe3, 0xe4, 0x3, 0x2, 0x2, 0x2, 0xe4, 0xe5, 0x3, 
    0x2, 0x2, 0x2, 0xe5, 0xe6, 0x7, 0x31, 0x2, 0x2, 0xe6, 0x13, 0x3, 0x2, 
    0x2, 0x2, 0xe7, 0x101, 0x7, 0xb, 0x2, 0x2, 0xe8, 0x100, 0x5, 0x14, 0xb, 
    0x2, 0xe9, 0x100, 0x5, 0x16, 0xc, 0x2, 0xea, 0x100, 0x5, 0x18, 0xd, 
    0x2, 0xeb, 0x100, 0x7, 0x56, 0x2, 0x2, 0xec, 0x100, 0x7, 0x57, 0x2, 
    0x2, 0xed, 0x100, 0x7, 0x53, 0x2, 0x2, 0xee, 0x100, 0x7, 0x54, 0x2, 
    0x2, 0xef, 0x100, 0x7, 0x55, 0x2, 0x2, 0xf0, 0x100, 0x7, 0x45, 0x2, 
    0x2, 0xf1, 0x100, 0x7, 0x46, 0x2, 0x2, 0xf2, 0x100, 0x7, 0x47, 0x2, 
    0x2, 0xf3, 0x100, 0x7, 0x48, 0x2, 0x2, 0xf4, 0x100, 0x7, 0x49, 0x2, 
    0x2, 0xf5, 0x100, 0x7, 0x4a, 0x2, 0x2, 0xf6, 0x100, 0x7, 0x4b, 0x2, 
    0x2, 0xf7, 0x100, 0x7, 0x4c, 0x2, 0x2, 0xf8, 0x100, 0x7, 0x50, 0x2, 
    0x2, 0xf9, 0x100, 0x7, 0x51, 0x2, 0x2, 0xfa, 0x100, 0x7, 0x52, 0x2, 
    0x2, 0xfb, 0x100, 0x7, 0x4e, 0x2, 0x2, 0xfc, 0x100, 0x7, 0x4d, 0x2, 
    0x2, 0xfd, 0x100, 0x7, 0x4f, 0x2, 0x2, 0xfe, 0x100, 0x7, 0x44, 0x2, 
    0x2, 0xff, 0xe8, 0x3, 0x2, 0x2, 0x2, 0xff, 0xe9, 0x3, 0x2, 0x2, 0x2, 
    0xff, 0xea, 0x3, 0x2, 0x2, 0x2, 0xff, 0xeb, 0x3, 0x2, 0x2, 0x2, 0xff, 
    0xec, 0x3, 0x2, 0x2, 0x2, 0xff, 0xed, 0x3, 0x2, 0x2, 0x2, 0xff, 0xee, 
    0x3, 0x2, 0x2, 0x2, 0xff, 0xef, 0x3, 0x2, 0x2, 0x2, 0xff, 0xf0, 0x3, 
    0x2, 0x2, 0x2, 0xff, 0xf1, 0x3, 0x2, 0x2, 0x2, 0xff, 0xf2, 0x3, 0x2, 
    0x2, 0x2, 0xff, 0xf3, 0x3, 0x2, 0x2, 0x2, 0xff, 0xf4, 0x3, 0x2, 0x2, 
    0x2, 0xff, 0xf5, 0x3, 0x2, 0x2, 0x2, 0xff, 0xf6, 0x3, 0x2, 0x2, 0x2, 
    0xff, 0xf7, 0x3, 0x2, 0x2, 0x2, 0xff, 0xf8, 0x3, 0x2, 0x2, 0x2, 0xff, 
    0xf9, 0x3, 0x2, 0x2, 0x2, 0xff, 0xfa, 0x3, 0x2, 0x2, 0x2, 0xff, 0xfb, 
    0x3, 0x2, 0x2, 0x2, 0xff, 0xfc, 0x3, 0x2, 0x2, 0x2, 0xff, 0xfd, 0x3, 
    0x2, 0x2, 0x2, 0xff, 0xfe, 0x3, 0x2, 0x2, 0x2, 0x100, 0x103, 0x3, 0x2, 
    0x2, 0x2, 0x101, 0xff, 0x3, 0x2, 0x2, 0x2, 0x101, 0x102, 0x3, 0x2, 0x2, 
    0x2, 0x102, 0x104, 0x3, 0x2, 0x2, 0x2, 0x103, 0x101, 0x3, 0x2, 0x2, 
    0x2, 0x104, 0x105, 0x7, 0x58, 0x2, 0x2, 0x105, 0x15, 0x3, 0x2, 0x2, 
    0x2, 0x106, 0x10a, 0x7, 0x52, 0x2, 0x2, 0x107, 0x109, 0x5, 0x24, 0x13, 
    0x2, 0x108, 0x107, 0x3, 0x2, 0x2, 0x2, 0x109, 0x10c, 0x3, 0x2, 0x2, 
    0x2, 0x10a, 0x108, 0x3, 0x2, 0x2, 0x2, 0x10a, 0x10b, 0x3, 0x2, 0x2, 
    0x2, 0x10b, 0x10d, 0x3, 0x2, 0x2, 0x2, 0x10c, 0x10a, 0x3, 0x2, 0x2, 
    0x2, 0x10d, 0x111, 0x7, 0x44, 0x2, 0x2, 0x10e, 0x110, 0x5, 0x24, 0x13, 
    0x2, 0x10f, 0x10e, 0x3, 0x2, 0x2, 0x2, 0x110, 0x113, 0x3, 0x2, 0x2, 
    0x2, 0x111, 0x10f, 0x3, 0x2, 0x2, 0x2, 0x111, 0x112, 0x3, 0x2, 0x2, 
    0x2, 0x112, 0x114, 0x3, 0x2, 0x2, 0x2, 0x113, 0x111, 0x3, 0x2, 0x2, 
    0x2, 0x114, 0x115, 0x7, 0x51, 0x2, 0x2, 0x115, 0x17, 0x3, 0x2, 0x2, 
    0x2, 0x116, 0x11a, 0x7, 0x52, 0x2, 0x2, 0x117, 0x119, 0x5, 0x24, 0x13, 
    0x2, 0x118, 0x117, 0x3, 0x2, 0x2, 0x2, 0x119, 0x11c, 0x3, 0x2, 0x2, 
    0x2, 0x11a, 0x118, 0x3, 0x2, 0x2, 0x2, 0x11a, 0x11b, 0x3, 0x2, 0x2, 
    0x2, 0x11b, 0x13b, 0x3, 0x2, 0x2, 0x2, 0x11c, 0x11a, 0x3, 0x2, 0x2, 
    0x2, 0x11d, 0x121, 0x7, 0x49, 0x2, 0x2, 0x11e, 0x120, 0x5, 0x24, 0x13, 
    0x2, 0x11f, 0x11e, 0x3, 0x2, 0x2, 0x2, 0x120, 0x123, 0x3, 0x2, 0x2, 
    0x2, 0x121, 0x11f, 0x3, 0x2, 0x2, 0x2, 0x121, 0x122, 0x3, 0x2, 0x2, 
    0x2, 0x122, 0x12b, 0x3, 0x2, 0x2, 0x2, 0x123, 0x121, 0x3, 0x2, 0x2, 
    0x2, 0x124, 0x128, 0x7, 0x4f, 0x2, 0x2, 0x125, 0x127, 0x5, 0x24, 0x13, 
    0x2, 0x126, 0x125, 0x3, 0x2, 0x2, 0x2, 0x127, 0x12a, 0x3, 0x2, 0x2, 
    0x2, 0x128, 0x126, 0x3, 0x2, 0x2, 0x2, 0x128, 0x129, 0x3, 0x2, 0x2, 
    0x2, 0x129, 0x12c, 0x3, 0x2, 0x2, 0x2, 0x12a, 0x128, 0x3, 0x2, 0x2, 
    0x2, 0x12b, 0x124, 0x3, 0x2, 0x2, 0x2, 0x12b, 0x12c, 0x3, 0x2, 0x2, 
    0x2, 0x12c, 0x12d, 0x3, 0x2, 0x2, 0x2, 0x12d, 0x131, 0x7, 0x51, 0x2, 
    0x2, 0x12e, 0x130, 0x5, 0x24, 0x13, 0x2, 0x12f, 0x12e, 0x3, 0x2, 0x2, 
    0x2, 0x130, 0x133, 0x3, 0x2, 0x2, 0x2, 0x131, 0x12f, 0x3, 0x2, 0x2, 
    0x2, 0x131, 0x132, 0x3, 0x2, 0x2, 0x2, 0x132, 0x134, 0x3, 0x2, 0x2, 
    0x2, 0x133, 0x131, 0x3, 0x2, 0x2, 0x2, 0x134, 0x138, 0x7, 0x4a, 0x2, 
    0x2, 0x135, 0x137, 0x5, 0x24, 0x13, 0x2, 0x136, 0x135, 0x3, 0x2, 0x2, 
    0x2, 0x137, 0x13a, 0x3, 0x2, 0x2, 0x2, 0x138, 0x136, 0x3, 0x2, 0x2, 
    0x2, 0x138, 0x139, 0x3, 0x2, 0x2, 0x2, 0x139, 0x13c, 0x3, 0x2, 0x2, 
    0x2, 0x13a, 0x138, 0x3, 0x2, 0x2, 0x2, 0x13b, 0x11d, 0x3, 0x2, 0x2, 
    0x2, 0x13b, 0x13c, 0x3, 0x2, 0x2, 0x2, 0x13c, 0x13d, 0x3, 0x2, 0x2, 
    0x2, 0x13d, 0x141, 0x7, 0x4d, 0x2, 0x2, 0x13e, 0x140, 0x5, 0x24, 0x13, 
    0x2, 0x13f, 0x13e, 0x3, 0x2, 0x2, 0x2, 0x140, 0x143, 0x3, 0x2, 0x2, 
    0x2, 0x141, 0x13f, 0x3, 0x2, 0x2, 0x2, 0x141, 0x142, 0x3, 0x2, 0x2, 
    0x2, 0x142, 0x144, 0x3, 0x2, 0x2, 0x2, 0x143, 0x141, 0x3, 0x2, 0x2, 
    0x2, 0x144, 0x145, 0x7, 0x51, 0x2, 0x2, 0x145, 0x19, 0x3, 0x2, 0x2, 
    0x2, 0x146, 0x14a, 0x7, 0xa, 0x2, 0x2, 0x147, 0x149, 0x9, 0x2, 0x2, 
    0x2, 0x148, 0x147, 0x3, 0x2, 0x2, 0x2, 0x149, 0x14c, 0x3, 0x2, 0x2, 
    0x2, 0x14a, 0x148, 0x3, 0x2, 0x2, 0x2, 0x14a, 0x14b, 0x3, 0x2, 0x2, 
    0x2, 0x14b, 0x14d, 0x3, 0x2, 0x2, 0x2, 0x14c, 0x14a, 0x3, 0x2, 0x2, 
    0x2, 0x14d, 0x14e, 0x7, 0x43, 0x2, 0x2, 0x14e, 0x1b, 0x3, 0x2, 0x2, 
    0x2, 0x14f, 0x153, 0x7, 0xa, 0x2, 0x2, 0x150, 0x152, 0x5, 0x24, 0x13, 
    0x2, 0x151, 0x150, 0x3, 0x2, 0x2, 0x2, 0x152, 0x155, 0x3, 0x2, 0x2, 
    0x2, 0x153, 0x151, 0x3, 0x2, 0x2, 0x2, 0x153, 0x154, 0x3, 0x2, 0x2, 
    0x2, 0x154, 0x170, 0x3, 0x2, 0x2, 0x2, 0x155, 0x153, 0x3, 0x2, 0x2, 
    0x2, 0x156, 0x15a, 0x5, 0x1e, 0x10, 0x2, 0x157, 0x159, 0x5, 0x24, 0x13, 
    0x2, 0x158, 0x157, 0x3, 0x2, 0x2, 0x2, 0x159, 0x15c, 0x3, 0x2, 0x2, 
    0x2, 0x15a, 0x158, 0x3, 0x2, 0x2, 0x2, 0x15a, 0x15b, 0x3, 0x2, 0x2, 
    0x2, 0x15b, 0x16d, 0x3, 0x2, 0x2, 0x2, 0x15c, 0x15a, 0x3, 0x2, 0x2, 
    0x2, 0x15d, 0x161, 0x7, 0x3c, 0x2, 0x2, 0x15e, 0x160, 0x5, 0x24, 0x13, 
    0x2, 0x15f, 0x15e, 0x3, 0x2, 0x2, 0x2, 0x160, 0x163, 0x3, 0x2, 0x2, 
    0x2, 0x161, 0x15f, 0x3, 0x2, 0x2, 0x2, 0x161, 0x162, 0x3, 0x2, 0x2, 
    0x2, 0x162, 0x164, 0x3, 0x2, 0x2, 0x2, 0x163, 0x161, 0x3, 0x2, 0x2, 
    0x2, 0x164, 0x168, 0x5, 0x1e, 0x10, 0x2, 0x165, 0x167, 0x5, 0x24, 0x13, 
    0x2, 0x166, 0x165, 0x3, 0x2, 0x2, 0x2, 0x167, 0x16a, 0x3, 0x2, 0x2, 
    0x2, 0x168, 0x166, 0x3, 0x2, 0x2, 0x2, 0x168, 0x169, 0x3, 0x2, 0x2, 
    0x2, 0x169, 0x16c, 0x3, 0x2, 0x2, 0x2, 0x16a, 0x168, 0x3, 0x2, 0x2, 
    0x2, 0x16b, 0x15d, 0x3, 0x2, 0x2, 0x2, 0x16c, 0x16f, 0x3, 0x2, 0x2, 
    0x2, 0x16d, 0x16b, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x16e, 0x3, 0x2, 0x2, 
    0x2, 0x16e, 0x171, 0x3, 0x2, 0x2, 0x2, 0x16f, 0x16d, 0x3, 0x2, 0x2, 
    0x2, 0x170, 0x156, 0x3, 0x2, 0x2, 0x2, 0x170, 0x171, 0x3, 0x2, 0x2, 
    0x2, 0x171, 0x172, 0x3, 0x2, 0x2, 0x2, 0x172, 0x173, 0x7, 0x43, 0x2, 
    0x2, 0x173, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x174, 0x176, 0x5, 0x20, 0x11, 
    0x2, 0x175, 0x174, 0x3, 0x2, 0x2, 0x2, 0x175, 0x176, 0x3, 0x2, 0x2, 
    0x2, 0x176, 0x17a, 0x3, 0x2, 0x2, 0x2, 0x177, 0x179, 0x5, 0x24, 0x13, 
    0x2, 0x178, 0x177, 0x3, 0x2, 0x2, 0x2, 0x179, 0x17c, 0x3, 0x2, 0x2, 
    0x2, 0x17a, 0x178, 0x3, 0x2, 0x2, 0x2, 0x17a, 0x17b, 0x3, 0x2, 0x2, 
    0x2, 0x17b, 0x17d, 0x3, 0x2, 0x2, 0x2, 0x17c, 0x17a, 0x3, 0x2, 0x2, 
    0x2, 0x17d, 0x17e, 0x7, 0x3e, 0x2, 0x2, 0x17e, 0x1f, 0x3, 0x2, 0x2, 
    0x2, 0x17f, 0x189, 0x5, 0x22, 0x12, 0x2, 0x180, 0x182, 0x5, 0x24, 0x13, 
    0x2, 0x181, 0x180, 0x3, 0x2, 0x2, 0x2, 0x182, 0x185, 0x3, 0x2, 0x2, 
    0x2, 0x183, 0x181, 0x3, 0x2, 0x2, 0x2, 0x183, 0x184, 0x3, 0x2, 0x2, 
    0x2, 0x184, 0x186, 0x3, 0x2, 0x2, 0x2, 0x185, 0x183, 0x3, 0x2, 0x2, 
    0x2, 0x186, 0x188, 0x5, 0x22, 0x12, 0x2, 0x187, 0x183, 0x3, 0x2, 0x2, 
    0x2, 0x188, 0x18b, 0x3, 0x2, 0x2, 0x2, 0x189, 0x187, 0x3, 0x2, 0x2, 
    0x2, 0x189, 0x18a, 0x3, 0x2, 0x2, 0x2, 0x18a, 0x21, 0x3, 0x2, 0x2, 0x2, 
    0x18b, 0x189, 0x3, 0x2, 0x2, 0x2, 0x18c, 0x198, 0x7, 0x3e, 0x2, 0x2, 
    0x18d, 0x18f, 0x7, 0x37, 0x2, 0x2, 0x18e, 0x190, 0x5, 0x20, 0x11, 0x2, 
    0x18f, 0x18e, 0x3, 0x2, 0x2, 0x2, 0x18f, 0x190, 0x3, 0x2, 0x2, 0x2, 
    0x190, 0x191, 0x3, 0x2, 0x2, 0x2, 0x191, 0x198, 0x7, 0x38, 0x2, 0x2, 
    0x192, 0x194, 0x7, 0x39, 0x2, 0x2, 0x193, 0x195, 0x5, 0x20, 0x11, 0x2, 
    0x194, 0x193, 0x3, 0x2, 0x2, 0x2, 0x194, 0x195, 0x3, 0x2, 0x2, 0x2, 
    0x195, 0x196, 0x3, 0x2, 0x2, 0x2, 0x196, 0x198, 0x7, 0x3a, 0x2, 0x2, 
    0x197, 0x18c, 0x3, 0x2, 0x2, 0x2, 0x197, 0x18d, 0x3, 0x2, 0x2, 0x2, 
    0x197, 0x192, 0x3, 0x2, 0x2, 0x2, 0x198, 0x23, 0x3, 0x2, 0x2, 0x2, 0x199, 
    0x19a, 0x9, 0x3, 0x2, 0x2, 0x19a, 0x25, 0x3, 0x2, 0x2, 0x2, 0x19b, 0x19f, 
    0x7, 0x2e, 0x2, 0x2, 0x19c, 0x19d, 0x5, 0x28, 0x15, 0x2, 0x19d, 0x19e, 
    0x7, 0x1d, 0x2, 0x2, 0x19e, 0x1a0, 0x3, 0x2, 0x2, 0x2, 0x19f, 0x19c, 
    0x3, 0x2, 0x2, 0x2, 0x19f, 0x1a0, 0x3, 0x2, 0x2, 0x2, 0x1a0, 0x1a1, 
    0x3, 0x2, 0x2, 0x2, 0x1a1, 0x1a2, 0x5, 0x8c, 0x47, 0x2, 0x1a2, 0x1a3, 
    0x5, 0x14, 0xb, 0x2, 0x1a3, 0x27, 0x3, 0x2, 0x2, 0x2, 0x1a4, 0x1a8, 
    0x5, 0x8c, 0x47, 0x2, 0x1a5, 0x1a8, 0x7, 0x10, 0x2, 0x2, 0x1a6, 0x1a8, 
    0x7, 0x11, 0x2, 0x2, 0x1a7, 0x1a4, 0x3, 0x2, 0x2, 0x2, 0x1a7, 0x1a5, 
    0x3, 0x2, 0x2, 0x2, 0x1a7, 0x1a6, 0x3, 0x2, 0x2, 0x2, 0x1a8, 0x29, 0x3, 
    0x2, 0x2, 0x2, 0x1a9, 0x1aa, 0x7, 0x1b, 0x2, 0x2, 0x1aa, 0x1ab, 0x5, 
    0x8c, 0x47, 0x2, 0x1ab, 0x1ad, 0x7, 0x1f, 0x2, 0x2, 0x1ac, 0x1ae, 0x5, 
    0x2e, 0x18, 0x2, 0x1ad, 0x1ac, 0x3, 0x2, 0x2, 0x2, 0x1ae, 0x1af, 0x3, 
    0x2, 0x2, 0x2, 0x1af, 0x1ad, 0x3, 0x2, 0x2, 0x2, 0x1af, 0x1b0, 0x3, 
    0x2, 0x2, 0x2, 0x1b0, 0x2b, 0x3, 0x2, 0x2, 0x2, 0x1b1, 0x1b3, 0x5, 0x2e, 
    0x18, 0x2, 0x1b2, 0x1b1, 0x3, 0x2, 0x2, 0x2, 0x1b3, 0x1b6, 0x3, 0x2, 
    0x2, 0x2, 0x1b4, 0x1b2, 0x3, 0x2, 0x2, 0x2, 0x1b4, 0x1b5, 0x3, 0x2, 
    0x2, 0x2, 0x1b5, 0x2d, 0x3, 0x2, 0x2, 0x2, 0x1b6, 0x1b4, 0x3, 0x2, 0x2, 
    0x2, 0x1b7, 0x1ba, 0x5, 0x30, 0x19, 0x2, 0x1b8, 0x1ba, 0x5, 0x4e, 0x28, 
    0x2, 0x1b9, 0x1b7, 0x3, 0x2, 0x2, 0x2, 0x1b9, 0x1b8, 0x3, 0x2, 0x2, 
    0x2, 0x1ba, 0x2f, 0x3, 0x2, 0x2, 0x2, 0x1bb, 0x1bd, 0x7, 0x6, 0x2, 0x2, 
    0x1bc, 0x1bb, 0x3, 0x2, 0x2, 0x2, 0x1bc, 0x1bd, 0x3, 0x2, 0x2, 0x2, 
    0x1bd, 0x1bf, 0x3, 0x2, 0x2, 0x2, 0x1be, 0x1c0, 0x5, 0x44, 0x23, 0x2, 
    0x1bf, 0x1be, 0x3, 0x2, 0x2, 0x2, 0x1bf, 0x1c0, 0x3, 0x2, 0x2, 0x2, 
    0x1c0, 0x1c1, 0x3, 0x2, 0x2, 0x2, 0x1c1, 0x1c3, 0x7, 0x4, 0x2, 0x2, 
    0x1c2, 0x1c4, 0x5, 0x1c, 0xf, 0x2, 0x1c3, 0x1c2, 0x3, 0x2, 0x2, 0x2, 
    0x1c3, 0x1c4, 0x3, 0x2, 0x2, 0x2, 0x1c4, 0x1c6, 0x3, 0x2, 0x2, 0x2, 
    0x1c5, 0x1c7, 0x5, 0x3c, 0x1f, 0x2, 0x1c6, 0x1c5, 0x3, 0x2, 0x2, 0x2, 
    0x1c6, 0x1c7, 0x3, 0x2, 0x2, 0x2, 0x1c7, 0x1c9, 0x3, 0x2, 0x2, 0x2, 
    0x1c8, 0x1ca, 0x5, 0x3e, 0x20, 0x2, 0x1c9, 0x1c8, 0x3, 0x2, 0x2, 0x2, 
    0x1c9, 0x1ca, 0x3, 0x2, 0x2, 0x2, 0x1ca, 0x1cc, 0x3, 0x2, 0x2, 0x2, 
    0x1cb, 0x1cd, 0x5, 0x40, 0x21, 0x2, 0x1cc, 0x1cb, 0x3, 0x2, 0x2, 0x2, 
    0x1cc, 0x1cd, 0x3, 0x2, 0x2, 0x2, 0x1cd, 0x1ce, 0x3, 0x2, 0x2, 0x2, 
    0x1ce, 0x1cf, 0x5, 0x38, 0x1d, 0x2, 0x1cf, 0x1d0, 0x7, 0x1c, 0x2, 0x2, 
    0x1d0, 0x1d1, 0x5, 0x48, 0x25, 0x2, 0x1d1, 0x1d2, 0x7, 0x1f, 0x2, 0x2, 
    0x1d2, 0x1d3, 0x5, 0x32, 0x1a, 0x2, 0x1d3, 0x1d4, 0x8, 0x19, 0x1, 0x2, 
    0x1d4, 0x31, 0x3, 0x2, 0x2, 0x2, 0x1d5, 0x1d7, 0x5, 0x34, 0x1b, 0x2, 
    0x1d6, 0x1d5, 0x3, 0x2, 0x2, 0x2, 0x1d7, 0x1da, 0x3, 0x2, 0x2, 0x2, 
    0x1d8, 0x1d6, 0x3, 0x2, 0x2, 0x2, 0x1d8, 0x1d9, 0x3, 0x2, 0x2, 0x2, 
    0x1d9, 0x1dc, 0x3, 0x2, 0x2, 0x2, 0x1da, 0x1d8, 0x3, 0x2, 0x2, 0x2, 
    0x1db, 0x1dd, 0x5, 0x36, 0x1c, 0x2, 0x1dc, 0x1db, 0x3, 0x2, 0x2, 0x2, 
    0x1dc, 0x1dd, 0x3, 0x2, 0x2, 0x2, 0x1dd, 0x33, 0x3, 0x2, 0x2, 0x2, 0x1de, 
    0x1df, 0x7, 0x19, 0x2, 0x2, 0x1df, 0x1e0, 0x5, 0x1a, 0xe, 0x2, 0x1e0, 
    0x1e1, 0x5, 0x14, 0xb, 0x2, 0x1e1, 0x35, 0x3, 0x2, 0x2, 0x2, 0x1e2, 
    0x1e3, 0x7, 0x1a, 0x2, 0x2, 0x1e3, 0x1e4, 0x5, 0x14, 0xb, 0x2, 0x1e4, 
    0x37, 0x3, 0x2, 0x2, 0x2, 0x1e5, 0x1e7, 0x5, 0x3a, 0x1e, 0x2, 0x1e6, 
    0x1e5, 0x3, 0x2, 0x2, 0x2, 0x1e7, 0x1ea, 0x3, 0x2, 0x2, 0x2, 0x1e8, 
    0x1e6, 0x3, 0x2, 0x2, 0x2, 0x1e8, 0x1e9, 0x3, 0x2, 0x2, 0x2, 0x1e9, 
    0x39, 0x3, 0x2, 0x2, 0x2, 0x1ea, 0x1e8, 0x3, 0x2, 0x2, 0x2, 0x1eb, 0x1ee, 
    0x5, 0x8, 0x5, 0x2, 0x1ec, 0x1ee, 0x5, 0x42, 0x22, 0x2, 0x1ed, 0x1eb, 
    0x3, 0x2, 0x2, 0x2, 0x1ed, 0x1ec, 0x3, 0x2, 0x2, 0x2, 0x1ee, 0x3b, 0x3, 
    0x2, 0x2, 0x2, 0x1ef, 0x1f0, 0x7, 0x16, 0x2, 0x2, 0x1f0, 0x1f1, 0x5, 
    0x1c, 0xf, 0x2, 0x1f1, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x1f2, 0x1f3, 0x7, 
    0x18, 0x2, 0x2, 0x1f3, 0x1f8, 0x5, 0x8e, 0x48, 0x2, 0x1f4, 0x1f5, 0x7, 
    0x1e, 0x2, 0x2, 0x1f5, 0x1f7, 0x5, 0x8e, 0x48, 0x2, 0x1f6, 0x1f4, 0x3, 
    0x2, 0x2, 0x2, 0x1f7, 0x1fa, 0x3, 0x2, 0x2, 0x2, 0x1f8, 0x1f6, 0x3, 
    0x2, 0x2, 0x2, 0x1f8, 0x1f9, 0x3, 0x2, 0x2, 0x2, 0x1f9, 0x3f, 0x3, 0x2, 
    0x2, 0x2, 0x1fa, 0x1f8, 0x3, 0x2, 0x2, 0x2, 0x1fb, 0x1fc, 0x7, 0x17, 
    0x2, 0x2, 0x1fc, 0x1fd, 0x5, 0x1c, 0xf, 0x2, 0x1fd, 0x41, 0x3, 0x2, 
    0x2, 0x2, 0x1fe, 0x1ff, 0x7, 0x2e, 0x2, 0x2, 0x1ff, 0x200, 0x5, 0x8c, 
    0x47, 0x2, 0x200, 0x201, 0x5, 0x14, 0xb, 0x2, 0x201, 0x43, 0x3, 0x2, 
    0x2, 0x2, 0x202, 0x204, 0x5, 0x46, 0x24, 0x2, 0x203, 0x202, 0x3, 0x2, 
    0x2, 0x2, 0x204, 0x205, 0x3, 0x2, 0x2, 0x2, 0x205, 0x203, 0x3, 0x2, 
    0x2, 0x2, 0x205, 0x206, 0x3, 0x2, 0x2, 0x2, 0x206, 0x45, 0x3, 0x2, 0x2, 
    0x2, 0x207, 0x208, 0x9, 0x4, 0x2, 0x2, 0x208, 0x47, 0x3, 0x2, 0x2, 0x2, 
    0x209, 0x20a, 0x5, 0x4a, 0x26, 0x2, 0x20a, 0x49, 0x3, 0x2, 0x2, 0x2, 
    0x20b, 0x210, 0x5, 0x4c, 0x27, 0x2, 0x20c, 0x20d, 0x7, 0x2a, 0x2, 0x2, 
    0x20d, 0x20f, 0x5, 0x4c, 0x27, 0x2, 0x20e, 0x20c, 0x3, 0x2, 0x2, 0x2, 
    0x20f, 0x212, 0x3, 0x2, 0x2, 0x2, 0x210, 0x20e, 0x3, 0x2, 0x2, 0x2, 
    0x210, 0x211, 0x3, 0x2, 0x2, 0x2, 0x211, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x212, 
    0x210, 0x3, 0x2, 0x2, 0x2, 0x213, 0x216, 0x5, 0x68, 0x35, 0x2, 0x214, 
    0x215, 0x7, 0x2f, 0x2, 0x2, 0x215, 0x217, 0x5, 0x8c, 0x47, 0x2, 0x216, 
    0x214, 0x3, 0x2, 0x2, 0x2, 0x216, 0x217, 0x3, 0x2, 0x2, 0x2, 0x217, 
    0x218, 0x3, 0x2, 0x2, 0x2, 0x218, 0x219, 0x8, 0x27, 0x1, 0x2, 0x219, 
    0x4d, 0x3, 0x2, 0x2, 0x2, 0x21a, 0x21c, 0x7, 0x6, 0x2, 0x2, 0x21b, 0x21a, 
    0x3, 0x2, 0x2, 0x2, 0x21b, 0x21c, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x21e, 
    0x3, 0x2, 0x2, 0x2, 0x21d, 0x21f, 0x7, 0xf, 0x2, 0x2, 0x21e, 0x21d, 
    0x3, 0x2, 0x2, 0x2, 0x21e, 0x21f, 0x3, 0x2, 0x2, 0x2, 0x21f, 0x220, 
    0x3, 0x2, 0x2, 0x2, 0x220, 0x221, 0x7, 0x3, 0x2, 0x2, 0x221, 0x222, 
    0x7, 0x1c, 0x2, 0x2, 0x222, 0x223, 0x5, 0x50, 0x29, 0x2, 0x223, 0x224, 
    0x7, 0x1f, 0x2, 0x2, 0x224, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x225, 0x226, 
    0x5, 0x52, 0x2a, 0x2, 0x226, 0x51, 0x3, 0x2, 0x2, 0x2, 0x227, 0x22c, 
    0x5, 0x54, 0x2b, 0x2, 0x228, 0x229, 0x7, 0x2a, 0x2, 0x2, 0x229, 0x22b, 
    0x5, 0x54, 0x2b, 0x2, 0x22a, 0x228, 0x3, 0x2, 0x2, 0x2, 0x22b, 0x22e, 
    0x3, 0x2, 0x2, 0x2, 0x22c, 0x22a, 0x3, 0x2, 0x2, 0x2, 0x22c, 0x22d, 
    0x3, 0x2, 0x2, 0x2, 0x22d, 0x53, 0x3, 0x2, 0x2, 0x2, 0x22e, 0x22c, 0x3, 
    0x2, 0x2, 0x2, 0x22f, 0x231, 0x5, 0x56, 0x2c, 0x2, 0x230, 0x22f, 0x3, 
    0x2, 0x2, 0x2, 0x230, 0x231, 0x3, 0x2, 0x2, 0x2, 0x231, 0x233, 0x3, 
    0x2, 0x2, 0x2, 0x232, 0x234, 0x5, 0x5e, 0x30, 0x2, 0x233, 0x232, 0x3, 
    0x2, 0x2, 0x2, 0x233, 0x234, 0x3, 0x2, 0x2, 0x2, 0x234, 0x55, 0x3, 0x2, 
    0x2, 0x2, 0x235, 0x237, 0x5, 0x58, 0x2d, 0x2, 0x236, 0x235, 0x3, 0x2, 
    0x2, 0x2, 0x237, 0x238, 0x3, 0x2, 0x2, 0x2, 0x238, 0x236, 0x3, 0x2, 
    0x2, 0x2, 0x238, 0x239, 0x3, 0x2, 0x2, 0x2, 0x239, 0x57, 0x3, 0x2, 0x2, 
    0x2, 0x23a, 0x23c, 0x5, 0x5a, 0x2e, 0x2, 0x23b, 0x23d, 0x5, 0x74, 0x3b, 
    0x2, 0x23c, 0x23b, 0x3, 0x2, 0x2, 0x2, 0x23c, 0x23d, 0x3, 0x2, 0x2, 
    0x2, 0x23d, 0x24b, 0x3, 0x2, 0x2, 0x2, 0x23e, 0x240, 0x5, 0x76, 0x3c, 
    0x2, 0x23f, 0x241, 0x5, 0x74, 0x3b, 0x2, 0x240, 0x23f, 0x3, 0x2, 0x2, 
    0x2, 0x240, 0x241, 0x3, 0x2, 0x2, 0x2, 0x241, 0x24b, 0x3, 0x2, 0x2, 
    0x2, 0x242, 0x244, 0x5, 0x5c, 0x2f, 0x2, 0x243, 0x245, 0x5, 0x74, 0x3b, 
    0x2, 0x244, 0x243, 0x3, 0x2, 0x2, 0x2, 0x244, 0x245, 0x3, 0x2, 0x2, 
    0x2, 0x245, 0x24b, 0x3, 0x2, 0x2, 0x2, 0x246, 0x248, 0x5, 0x14, 0xb, 
    0x2, 0x247, 0x249, 0x7, 0x26, 0x2, 0x2, 0x248, 0x247, 0x3, 0x2, 0x2, 
    0x2, 0x248, 0x249, 0x3, 0x2, 0x2, 0x2, 0x249, 0x24b, 0x3, 0x2, 0x2, 
    0x2, 0x24a, 0x23a, 0x3, 0x2, 0x2, 0x2, 0x24a, 0x23e, 0x3, 0x2, 0x2, 
    0x2, 0x24a, 0x242, 0x3, 0x2, 0x2, 0x2, 0x24a, 0x246, 0x3, 0x2, 0x2, 
    0x2, 0x24b, 0x59, 0x3, 0x2, 0x2, 0x2, 0x24c, 0x24d, 0x5, 0x8c, 0x47, 
    0x2, 0x24d, 0x250, 0x9, 0x5, 0x2, 0x2, 0x24e, 0x251, 0x5, 0x76, 0x3c, 
    0x2, 0x24f, 0x251, 0x5, 0x80, 0x41, 0x2, 0x250, 0x24e, 0x3, 0x2, 0x2, 
    0x2, 0x250, 0x24f, 0x3, 0x2, 0x2, 0x2, 0x251, 0x5b, 0x3, 0x2, 0x2, 0x2, 
    0x252, 0x253, 0x7, 0x20, 0x2, 0x2, 0x253, 0x254, 0x5, 0x52, 0x2a, 0x2, 
    0x254, 0x255, 0x7, 0x21, 0x2, 0x2, 0x255, 0x5d, 0x3, 0x2, 0x2, 0x2, 
    0x256, 0x257, 0x7, 0x22, 0x2, 0x2, 0x257, 0x25c, 0x5, 0x60, 0x31, 0x2, 
    0x258, 0x259, 0x7, 0x1e, 0x2, 0x2, 0x259, 0x25b, 0x5, 0x60, 0x31, 0x2, 
    0x25a, 0x258, 0x3, 0x2, 0x2, 0x2, 0x25b, 0x25e, 0x3, 0x2, 0x2, 0x2, 
    0x25c, 0x25a, 0x3, 0x2, 0x2, 0x2, 0x25c, 0x25d, 0x3, 0x2, 0x2, 0x2, 
    0x25d, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x25e, 0x25c, 0x3, 0x2, 0x2, 0x2, 0x25f, 
    0x260, 0x5, 0x62, 0x32, 0x2, 0x260, 0x261, 0x7, 0x20, 0x2, 0x2, 0x261, 
    0x262, 0x5, 0x64, 0x33, 0x2, 0x262, 0x263, 0x7, 0x21, 0x2, 0x2, 0x263, 
    0x266, 0x3, 0x2, 0x2, 0x2, 0x264, 0x266, 0x5, 0x62, 0x32, 0x2, 0x265, 
    0x25f, 0x3, 0x2, 0x2, 0x2, 0x265, 0x264, 0x3, 0x2, 0x2, 0x2, 0x266, 
    0x61, 0x3, 0x2, 0x2, 0x2, 0x267, 0x26a, 0x5, 0x8c, 0x47, 0x2, 0x268, 
    0x26a, 0x7, 0x1b, 0x2, 0x2, 0x269, 0x267, 0x3, 0x2, 0x2, 0x2, 0x269, 
    0x268, 0x3, 0x2, 0x2, 0x2, 0x26a, 0x63, 0x3, 0x2, 0x2, 0x2, 0x26b, 0x26e, 
    0x5, 0x8c, 0x47, 0x2, 0x26c, 0x26e, 0x7, 0x33, 0x2, 0x2, 0x26d, 0x26b, 
    0x3, 0x2, 0x2, 0x2, 0x26d, 0x26c, 0x3, 0x2, 0x2, 0x2, 0x26e, 0x65, 0x3, 
    0x2, 0x2, 0x2, 0x26f, 0x274, 0x5, 0x68, 0x35, 0x2, 0x270, 0x271, 0x7, 
    0x2a, 0x2, 0x2, 0x271, 0x273, 0x5, 0x68, 0x35, 0x2, 0x272, 0x270, 0x3, 
    0x2, 0x2, 0x2, 0x273, 0x276, 0x3, 0x2, 0x2, 0x2, 0x274, 0x272, 0x3, 
    0x2, 0x2, 0x2, 0x274, 0x275, 0x3, 0x2, 0x2, 0x2, 0x275, 0x67, 0x3, 0x2, 
    0x2, 0x2, 0x276, 0x274, 0x3, 0x2, 0x2, 0x2, 0x277, 0x27a, 0x5, 0x6a, 
    0x36, 0x2, 0x278, 0x27a, 0x3, 0x2, 0x2, 0x2, 0x279, 0x277, 0x3, 0x2, 
    0x2, 0x2, 0x279, 0x278, 0x3, 0x2, 0x2, 0x2, 0x27a, 0x69, 0x3, 0x2, 0x2, 
    0x2, 0x27b, 0x27d, 0x5, 0x6c, 0x37, 0x2, 0x27c, 0x27b, 0x3, 0x2, 0x2, 
    0x2, 0x27d, 0x27e, 0x3, 0x2, 0x2, 0x2, 0x27e, 0x27c, 0x3, 0x2, 0x2, 
    0x2, 0x27e, 0x27f, 0x3, 0x2, 0x2, 0x2, 0x27f, 0x6b, 0x3, 0x2, 0x2, 0x2, 
    0x280, 0x283, 0x5, 0x6e, 0x38, 0x2, 0x281, 0x284, 0x5, 0x74, 0x3b, 0x2, 
    0x282, 0x284, 0x3, 0x2, 0x2, 0x2, 0x283, 0x281, 0x3, 0x2, 0x2, 0x2, 
    0x283, 0x282, 0x3, 0x2, 0x2, 0x2, 0x284, 0x290, 0x3, 0x2, 0x2, 0x2, 
    0x285, 0x288, 0x5, 0x78, 0x3d, 0x2, 0x286, 0x289, 0x5, 0x74, 0x3b, 0x2, 
    0x287, 0x289, 0x3, 0x2, 0x2, 0x2, 0x288, 0x286, 0x3, 0x2, 0x2, 0x2, 
    0x288, 0x287, 0x3, 0x2, 0x2, 0x2, 0x289, 0x290, 0x3, 0x2, 0x2, 0x2, 
    0x28a, 0x290, 0x5, 0x70, 0x39, 0x2, 0x28b, 0x28d, 0x5, 0x14, 0xb, 0x2, 
    0x28c, 0x28e, 0x7, 0x26, 0x2, 0x2, 0x28d, 0x28c, 0x3, 0x2, 0x2, 0x2, 
    0x28d, 0x28e, 0x3, 0x2, 0x2, 0x2, 0x28e, 0x290, 0x3, 0x2, 0x2, 0x2, 
    0x28f, 0x280, 0x3, 0x2, 0x2, 0x2, 0x28f, 0x285, 0x3, 0x2, 0x2, 0x2, 
    0x28f, 0x28a, 0x3, 0x2, 0x2, 0x2, 0x28f, 0x28b, 0x3, 0x2, 0x2, 0x2, 
    0x290, 0x6d, 0x3, 0x2, 0x2, 0x2, 0x291, 0x292, 0x5, 0x8c, 0x47, 0x2, 
    0x292, 0x295, 0x9, 0x5, 0x2, 0x2, 0x293, 0x296, 0x5, 0x78, 0x3d, 0x2, 
    0x294, 0x296, 0x5, 0x80, 0x41, 0x2, 0x295, 0x293, 0x3, 0x2, 0x2, 0x2, 
    0x295, 0x294, 0x3, 0x2, 0x2, 0x2, 0x296, 0x6f, 0x3, 0x2, 0x2, 0x2, 0x297, 
    0x29a, 0x5, 0x80, 0x41, 0x2, 0x298, 0x29b, 0x5, 0x72, 0x3a, 0x2, 0x299, 
    0x29b, 0x3, 0x2, 0x2, 0x2, 0x29a, 0x298, 0x3, 0x2, 0x2, 0x2, 0x29a, 
    0x299, 0x3, 0x2, 0x2, 0x2, 0x29b, 0x71, 0x3, 0x2, 0x2, 0x2, 0x29c, 0x29d, 
    0x5, 0x74, 0x3b, 0x2, 0x29d, 0x73, 0x3, 0x2, 0x2, 0x2, 0x29e, 0x29f, 
    0x9, 0x6, 0x2, 0x2, 0x29f, 0x75, 0x3, 0x2, 0x2, 0x2, 0x2a0, 0x2aa, 0x5, 
    0x84, 0x43, 0x2, 0x2a1, 0x2aa, 0x5, 0x86, 0x44, 0x2, 0x2a2, 0x2aa, 0x7, 
    0x4, 0x2, 0x2, 0x2a3, 0x2aa, 0x5, 0x7a, 0x3e, 0x2, 0x2a4, 0x2aa, 0x7, 
    0x5, 0x2, 0x2, 0x2a5, 0x2a7, 0x7, 0x2c, 0x2, 0x2, 0x2a6, 0x2a8, 0x5, 
    0x88, 0x45, 0x2, 0x2a7, 0x2a6, 0x3, 0x2, 0x2, 0x2, 0x2a7, 0x2a8, 0x3, 
    0x2, 0x2, 0x2, 0x2a8, 0x2aa, 0x3, 0x2, 0x2, 0x2, 0x2a9, 0x2a0, 0x3, 
    0x2, 0x2, 0x2, 0x2a9, 0x2a1, 0x3, 0x2, 0x2, 0x2, 0x2a9, 0x2a2, 0x3, 
    0x2, 0x2, 0x2, 0x2a9, 0x2a3, 0x3, 0x2, 0x2, 0x2, 0x2a9, 0x2a4, 0x3, 
    0x2, 0x2, 0x2, 0x2a9, 0x2a5, 0x3, 0x2, 0x2, 0x2, 0x2aa, 0x77, 0x3, 0x2, 
    0x2, 0x2, 0x2ab, 0x2b4, 0x5, 0x84, 0x43, 0x2, 0x2ac, 0x2b4, 0x5, 0x86, 
    0x44, 0x2, 0x2ad, 0x2b4, 0x5, 0x82, 0x42, 0x2, 0x2ae, 0x2b4, 0x5, 0x7a, 
    0x3e, 0x2, 0x2af, 0x2b1, 0x7, 0x2c, 0x2, 0x2, 0x2b0, 0x2b2, 0x5, 0x88, 
    0x45, 0x2, 0x2b1, 0x2b0, 0x3, 0x2, 0x2, 0x2, 0x2b1, 0x2b2, 0x3, 0x2, 
    0x2, 0x2, 0x2b2, 0x2b4, 0x3, 0x2, 0x2, 0x2, 0x2b3, 0x2ab, 0x3, 0x2, 
    0x2, 0x2, 0x2b3, 0x2ac, 0x3, 0x2, 0x2, 0x2, 0x2b3, 0x2ad, 0x3, 0x2, 
    0x2, 0x2, 0x2b3, 0x2ae, 0x3, 0x2, 0x2, 0x2, 0x2b3, 0x2af, 0x3, 0x2, 
    0x2, 0x2, 0x2b4, 0x79, 0x3, 0x2, 0x2, 0x2, 0x2b5, 0x2b6, 0x7, 0x30, 
    0x2, 0x2, 0x2b6, 0x2ba, 0x5, 0x7e, 0x40, 0x2, 0x2b7, 0x2b8, 0x7, 0x30, 
    0x2, 0x2, 0x2b8, 0x2ba, 0x5, 0x7c, 0x3f, 0x2, 0x2b9, 0x2b5, 0x3, 0x2, 
    0x2, 0x2, 0x2b9, 0x2b7, 0x3, 0x2, 0x2, 0x2, 0x2ba, 0x7b, 0x3, 0x2, 0x2, 
    0x2, 0x2bb, 0x2bc, 0x7, 0x20, 0x2, 0x2, 0x2bc, 0x2c1, 0x5, 0x7e, 0x40, 
    0x2, 0x2bd, 0x2be, 0x7, 0x2a, 0x2, 0x2, 0x2be, 0x2c0, 0x5, 0x7e, 0x40, 
    0x2, 0x2bf, 0x2bd, 0x3, 0x2, 0x2, 0x2, 0x2c0, 0x2c3, 0x3, 0x2, 0x2, 
    0x2, 0x2c1, 0x2bf, 0x3, 0x2, 0x2, 0x2, 0x2c1, 0x2c2, 0x3, 0x2, 0x2, 
    0x2, 0x2c2, 0x2c4, 0x3, 0x2, 0x2, 0x2, 0x2c3, 0x2c1, 0x3, 0x2, 0x2, 
    0x2, 0x2c4, 0x2c5, 0x7, 0x21, 0x2, 0x2, 0x2c5, 0x7d, 0x3, 0x2, 0x2, 
    0x2, 0x2c6, 0x2cb, 0x7, 0x3, 0x2, 0x2, 0x2c7, 0x2cb, 0x7, 0x34, 0x2, 
    0x2, 0x2c8, 0x2cb, 0x5, 0x84, 0x43, 0x2, 0x2c9, 0x2cb, 0x7, 0x5, 0x2, 
    0x2, 0x2ca, 0x2c6, 0x3, 0x2, 0x2, 0x2, 0x2ca, 0x2c7, 0x3, 0x2, 0x2, 
    0x2, 0x2ca, 0x2c8, 0x3, 0x2, 0x2, 0x2, 0x2ca, 0x2c9, 0x3, 0x2, 0x2, 
    0x2, 0x2cb, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x2cc, 0x2d7, 0x7, 0x20, 0x2, 
    0x2, 0x2cd, 0x2cf, 0x5, 0x8, 0x5, 0x2, 0x2ce, 0x2cd, 0x3, 0x2, 0x2, 
    0x2, 0x2ce, 0x2cf, 0x3, 0x2, 0x2, 0x2, 0x2cf, 0x2d3, 0x3, 0x2, 0x2, 
    0x2, 0x2d0, 0x2d2, 0x5, 0x42, 0x22, 0x2, 0x2d1, 0x2d0, 0x3, 0x2, 0x2, 
    0x2, 0x2d2, 0x2d5, 0x3, 0x2, 0x2, 0x2, 0x2d3, 0x2d1, 0x3, 0x2, 0x2, 
    0x2, 0x2d3, 0x2d4, 0x3, 0x2, 0x2, 0x2, 0x2d4, 0x2d6, 0x3, 0x2, 0x2, 
    0x2, 0x2d5, 0x2d3, 0x3, 0x2, 0x2, 0x2, 0x2d6, 0x2d8, 0x7, 0x1c, 0x2, 
    0x2, 0x2d7, 0x2ce, 0x3, 0x2, 0x2, 0x2, 0x2d7, 0x2d8, 0x3, 0x2, 0x2, 
    0x2, 0x2d8, 0x2d9, 0x3, 0x2, 0x2, 0x2, 0x2d9, 0x2da, 0x5, 0x66, 0x34, 
    0x2, 0x2da, 0x2db, 0x7, 0x21, 0x2, 0x2, 0x2db, 0x81, 0x3, 0x2, 0x2, 
    0x2, 0x2dc, 0x2de, 0x7, 0x4, 0x2, 0x2, 0x2dd, 0x2df, 0x5, 0x1a, 0xe, 
    0x2, 0x2de, 0x2dd, 0x3, 0x2, 0x2, 0x2, 0x2de, 0x2df, 0x3, 0x2, 0x2, 
    0x2, 0x2df, 0x83, 0x3, 0x2, 0x2, 0x2, 0x2e0, 0x2e1, 0x7, 0x34, 0x2, 
    0x2, 0x2e1, 0x2e2, 0x7, 0x2d, 0x2, 0x2, 0x2e2, 0x2e3, 0x7, 0x34, 0x2, 
    0x2, 0x2e3, 0x85, 0x3, 0x2, 0x2, 0x2, 0x2e4, 0x2e6, 0x7, 0x3, 0x2, 0x2, 
    0x2e5, 0x2e7, 0x5, 0x88, 0x45, 0x2, 0x2e6, 0x2e5, 0x3, 0x2, 0x2, 0x2, 
    0x2e6, 0x2e7, 0x3, 0x2, 0x2, 0x2, 0x2e7, 0x2ed, 0x3, 0x2, 0x2, 0x2, 
    0x2e8, 0x2ea, 0x7, 0x34, 0x2, 0x2, 0x2e9, 0x2eb, 0x5, 0x88, 0x45, 0x2, 
    0x2ea, 0x2e9, 0x3, 0x2, 0x2, 0x2, 0x2ea, 0x2eb, 0x3, 0x2, 0x2, 0x2, 
    0x2eb, 0x2ed, 0x3, 0x2, 0x2, 0x2, 0x2ec, 0x2e4, 0x3, 0x2, 0x2, 0x2, 
    0x2ec, 0x2e8, 0x3, 0x2, 0x2, 0x2, 0x2ed, 0x87, 0x3, 0x2, 0x2, 0x2, 0x2ee, 
    0x2ef, 0x7, 0x23, 0x2, 0x2, 0x2ef, 0x2f4, 0x5, 0x8a, 0x46, 0x2, 0x2f0, 
    0x2f1, 0x7, 0x1e, 0x2, 0x2, 0x2f1, 0x2f3, 0x5, 0x8a, 0x46, 0x2, 0x2f2, 
    0x2f0, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2f6, 0x3, 0x2, 0x2, 0x2, 0x2f4, 
    0x2f2, 0x3, 0x2, 0x2, 0x2, 0x2f4, 0x2f5, 0x3, 0x2, 0x2, 0x2, 0x2f5, 
    0x2f7, 0x3, 0x2, 0x2, 0x2, 0x2f6, 0x2f4, 0x3, 0x2, 0x2, 0x2, 0x2f7, 
    0x2f8, 0x7, 0x24, 0x2, 0x2, 0x2f8, 0x89, 0x3, 0x2, 0x2, 0x2, 0x2f9, 
    0x301, 0x5, 0x8e, 0x48, 0x2, 0x2fa, 0x2fb, 0x5, 0x8c, 0x47, 0x2, 0x2fb, 
    0x2fe, 0x7, 0x25, 0x2, 0x2, 0x2fc, 0x2ff, 0x5, 0x8e, 0x48, 0x2, 0x2fd, 
    0x2ff, 0x7, 0x34, 0x2, 0x2, 0x2fe, 0x2fc, 0x3, 0x2, 0x2, 0x2, 0x2fe, 
    0x2fd, 0x3, 0x2, 0x2, 0x2, 0x2ff, 0x301, 0x3, 0x2, 0x2, 0x2, 0x300, 
    0x2f9, 0x3, 0x2, 0x2, 0x2, 0x300, 0x2fa, 0x3, 0x2, 0x2, 0x2, 0x301, 
    0x8b, 0x3, 0x2, 0x2, 0x2, 0x302, 0x303, 0x9, 0x7, 0x2, 0x2, 0x303, 0x8d, 
    0x3, 0x2, 0x2, 0x2, 0x304, 0x309, 0x5, 0x8c, 0x47, 0x2, 0x305, 0x306, 
    0x7, 0x2c, 0x2, 0x2, 0x306, 0x308, 0x5, 0x8c, 0x47, 0x2, 0x307, 0x305, 
    0x3, 0x2, 0x2, 0x2, 0x308, 0x30b, 0x3, 0x2, 0x2, 0x2, 0x309, 0x307, 
    0x3, 0x2, 0x2, 0x2, 0x309, 0x30a, 0x3, 0x2, 0x2, 0x2, 0x30a, 0x8f, 0x3, 
    0x2, 0x2, 0x2, 0x30b, 0x309, 0x3, 0x2, 0x2, 0x2, 0x65, 0x91, 0x99, 0xa0, 
    0xaa, 0xb0, 0xb8, 0xc5, 0xcd, 0xd7, 0xdf, 0xe3, 0xff, 0x101, 0x10a, 
    0x111, 0x11a, 0x121, 0x128, 0x12b, 0x131, 0x138, 0x13b, 0x141, 0x14a, 
    0x153, 0x15a, 0x161, 0x168, 0x16d, 0x170, 0x175, 0x17a, 0x183, 0x189, 
    0x18f, 0x194, 0x197, 0x19f, 0x1a7, 0x1af, 0x1b4, 0x1b9, 0x1bc, 0x1bf, 
    0x1c3, 0x1c6, 0x1c9, 0x1cc, 0x1d8, 0x1dc, 0x1e8, 0x1ed, 0x1f8, 0x205, 
    0x210, 0x216, 0x21b, 0x21e, 0x22c, 0x230, 0x233, 0x238, 0x23c, 0x240, 
    0x244, 0x248, 0x24a, 0x250, 0x25c, 0x265, 0x269, 0x26d, 0x274, 0x279, 
    0x27e, 0x283, 0x288, 0x28d, 0x28f, 0x295, 0x29a, 0x2a7, 0x2a9, 0x2b1, 
    0x2b3, 0x2b9, 0x2c1, 0x2ca, 0x2ce, 0x2d3, 0x2d7, 0x2de, 0x2e6, 0x2ea, 
    0x2ec, 0x2f4, 0x2fe, 0x300, 0x309, 
  };

  atn::ATNDeserializer deserializer;
  _atn = deserializer.deserialize(_serializedATN);

  size_t count = _atn.getNumberOfDecisions();
  _decisionToDFA.reserve(count);
  for (size_t i = 0; i < count; i++) { 
    _decisionToDFA.emplace_back(_atn.getDecisionState(i), i);
  }
}

ANTLRv4Parser::Initializer ANTLRv4Parser::_init;
